1#[derive(Clone, Copy, PartialEq, Eq, Hash, Debug)]
5#[repr(i32)]
6pub enum Edition {
7 EDITION_UNKNOWN = 0i32,
8 EDITION_LEGACY = 900i32,
9 EDITION_PROTO2 = 998i32,
10 EDITION_PROTO3 = 999i32,
11 EDITION_2023 = 1000i32,
12 EDITION_2024 = 1001i32,
13 EDITION_UNSTABLE = 9999i32,
14 EDITION_1_TEST_ONLY = 1i32,
15 EDITION_2_TEST_ONLY = 2i32,
16 EDITION_99997_TEST_ONLY = 99997i32,
17 EDITION_99998_TEST_ONLY = 99998i32,
18 EDITION_99999_TEST_ONLY = 99999i32,
19 EDITION_MAX = 2147483647i32,
20}
21impl ::core::default::Default for Edition {
22 fn default() -> Self {
23 Self::EDITION_UNKNOWN
24 }
25}
26impl ::buffa::Enumeration for Edition {
27 fn from_i32(value: i32) -> ::core::option::Option<Self> {
28 match value {
29 0i32 => ::core::option::Option::Some(Self::EDITION_UNKNOWN),
30 900i32 => ::core::option::Option::Some(Self::EDITION_LEGACY),
31 998i32 => ::core::option::Option::Some(Self::EDITION_PROTO2),
32 999i32 => ::core::option::Option::Some(Self::EDITION_PROTO3),
33 1000i32 => ::core::option::Option::Some(Self::EDITION_2023),
34 1001i32 => ::core::option::Option::Some(Self::EDITION_2024),
35 9999i32 => ::core::option::Option::Some(Self::EDITION_UNSTABLE),
36 1i32 => ::core::option::Option::Some(Self::EDITION_1_TEST_ONLY),
37 2i32 => ::core::option::Option::Some(Self::EDITION_2_TEST_ONLY),
38 99997i32 => ::core::option::Option::Some(Self::EDITION_99997_TEST_ONLY),
39 99998i32 => ::core::option::Option::Some(Self::EDITION_99998_TEST_ONLY),
40 99999i32 => ::core::option::Option::Some(Self::EDITION_99999_TEST_ONLY),
41 2147483647i32 => ::core::option::Option::Some(Self::EDITION_MAX),
42 _ => ::core::option::Option::None,
43 }
44 }
45 fn to_i32(&self) -> i32 {
46 *self as i32
47 }
48 fn proto_name(&self) -> &'static str {
49 match self {
50 Self::EDITION_UNKNOWN => "EDITION_UNKNOWN",
51 Self::EDITION_LEGACY => "EDITION_LEGACY",
52 Self::EDITION_PROTO2 => "EDITION_PROTO2",
53 Self::EDITION_PROTO3 => "EDITION_PROTO3",
54 Self::EDITION_2023 => "EDITION_2023",
55 Self::EDITION_2024 => "EDITION_2024",
56 Self::EDITION_UNSTABLE => "EDITION_UNSTABLE",
57 Self::EDITION_1_TEST_ONLY => "EDITION_1_TEST_ONLY",
58 Self::EDITION_2_TEST_ONLY => "EDITION_2_TEST_ONLY",
59 Self::EDITION_99997_TEST_ONLY => "EDITION_99997_TEST_ONLY",
60 Self::EDITION_99998_TEST_ONLY => "EDITION_99998_TEST_ONLY",
61 Self::EDITION_99999_TEST_ONLY => "EDITION_99999_TEST_ONLY",
62 Self::EDITION_MAX => "EDITION_MAX",
63 }
64 }
65 fn from_proto_name(name: &str) -> ::core::option::Option<Self> {
66 match name {
67 "EDITION_UNKNOWN" => ::core::option::Option::Some(Self::EDITION_UNKNOWN),
68 "EDITION_LEGACY" => ::core::option::Option::Some(Self::EDITION_LEGACY),
69 "EDITION_PROTO2" => ::core::option::Option::Some(Self::EDITION_PROTO2),
70 "EDITION_PROTO3" => ::core::option::Option::Some(Self::EDITION_PROTO3),
71 "EDITION_2023" => ::core::option::Option::Some(Self::EDITION_2023),
72 "EDITION_2024" => ::core::option::Option::Some(Self::EDITION_2024),
73 "EDITION_UNSTABLE" => ::core::option::Option::Some(Self::EDITION_UNSTABLE),
74 "EDITION_1_TEST_ONLY" => {
75 ::core::option::Option::Some(Self::EDITION_1_TEST_ONLY)
76 }
77 "EDITION_2_TEST_ONLY" => {
78 ::core::option::Option::Some(Self::EDITION_2_TEST_ONLY)
79 }
80 "EDITION_99997_TEST_ONLY" => {
81 ::core::option::Option::Some(Self::EDITION_99997_TEST_ONLY)
82 }
83 "EDITION_99998_TEST_ONLY" => {
84 ::core::option::Option::Some(Self::EDITION_99998_TEST_ONLY)
85 }
86 "EDITION_99999_TEST_ONLY" => {
87 ::core::option::Option::Some(Self::EDITION_99999_TEST_ONLY)
88 }
89 "EDITION_MAX" => ::core::option::Option::Some(Self::EDITION_MAX),
90 _ => ::core::option::Option::None,
91 }
92 }
93}
94#[derive(Clone, Copy, PartialEq, Eq, Hash, Debug)]
95#[repr(i32)]
96pub enum SymbolVisibility {
97 VISIBILITY_UNSET = 0i32,
98 VISIBILITY_LOCAL = 1i32,
99 VISIBILITY_EXPORT = 2i32,
100}
101impl ::core::default::Default for SymbolVisibility {
102 fn default() -> Self {
103 Self::VISIBILITY_UNSET
104 }
105}
106impl ::buffa::Enumeration for SymbolVisibility {
107 fn from_i32(value: i32) -> ::core::option::Option<Self> {
108 match value {
109 0i32 => ::core::option::Option::Some(Self::VISIBILITY_UNSET),
110 1i32 => ::core::option::Option::Some(Self::VISIBILITY_LOCAL),
111 2i32 => ::core::option::Option::Some(Self::VISIBILITY_EXPORT),
112 _ => ::core::option::Option::None,
113 }
114 }
115 fn to_i32(&self) -> i32 {
116 *self as i32
117 }
118 fn proto_name(&self) -> &'static str {
119 match self {
120 Self::VISIBILITY_UNSET => "VISIBILITY_UNSET",
121 Self::VISIBILITY_LOCAL => "VISIBILITY_LOCAL",
122 Self::VISIBILITY_EXPORT => "VISIBILITY_EXPORT",
123 }
124 }
125 fn from_proto_name(name: &str) -> ::core::option::Option<Self> {
126 match name {
127 "VISIBILITY_UNSET" => ::core::option::Option::Some(Self::VISIBILITY_UNSET),
128 "VISIBILITY_LOCAL" => ::core::option::Option::Some(Self::VISIBILITY_LOCAL),
129 "VISIBILITY_EXPORT" => ::core::option::Option::Some(Self::VISIBILITY_EXPORT),
130 _ => ::core::option::Option::None,
131 }
132 }
133}
134#[derive(Clone, PartialEq, Default)]
135pub struct FileDescriptorSet {
136 pub file: ::buffa::alloc::vec::Vec<FileDescriptorProto>,
138 #[doc(hidden)]
139 pub __buffa_unknown_fields: ::buffa::UnknownFields,
140 #[doc(hidden)]
141 pub __buffa_cached_size: ::buffa::__private::CachedSize,
142}
143impl ::core::fmt::Debug for FileDescriptorSet {
144 fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
145 f.debug_struct("FileDescriptorSet").field("file", &self.file).finish()
146 }
147}
148impl FileDescriptorSet {
149 pub const TYPE_URL: &'static str = "type.googleapis.com/google.protobuf.FileDescriptorSet";
154}
155unsafe impl ::buffa::DefaultInstance for FileDescriptorSet {
156 fn default_instance() -> &'static Self {
157 static VALUE: ::buffa::__private::OnceBox<FileDescriptorSet> = ::buffa::__private::OnceBox::new();
158 VALUE
159 .get_or_init(|| ::buffa::alloc::boxed::Box::new(
160 FileDescriptorSet::default(),
161 ))
162 }
163}
164impl ::buffa::Message for FileDescriptorSet {
165 fn compute_size(&self) -> u32 {
171 #[allow(unused_imports)]
172 use ::buffa::Enumeration as _;
173 let mut size = 0u32;
174 for v in &self.file {
175 let inner_size = v.compute_size();
176 size
177 += 1u32 + ::buffa::encoding::varint_len(inner_size as u64) as u32
178 + inner_size;
179 }
180 size += self.__buffa_unknown_fields.encoded_len() as u32;
181 self.__buffa_cached_size.set(size);
182 size
183 }
184 fn write_to(&self, buf: &mut impl ::buffa::bytes::BufMut) {
185 #[allow(unused_imports)]
186 use ::buffa::Enumeration as _;
187 for v in &self.file {
188 ::buffa::encoding::Tag::new(
189 1u32,
190 ::buffa::encoding::WireType::LengthDelimited,
191 )
192 .encode(buf);
193 ::buffa::encoding::encode_varint(v.cached_size() as u64, buf);
194 v.write_to(buf);
195 }
196 self.__buffa_unknown_fields.write_to(buf);
197 }
198 fn merge_field(
199 &mut self,
200 tag: ::buffa::encoding::Tag,
201 buf: &mut impl ::buffa::bytes::Buf,
202 depth: u32,
203 ) -> ::core::result::Result<(), ::buffa::DecodeError> {
204 #[allow(unused_imports)]
205 use ::buffa::bytes::Buf as _;
206 #[allow(unused_imports)]
207 use ::buffa::Enumeration as _;
208 match tag.field_number() {
209 1u32 => {
210 if tag.wire_type() != ::buffa::encoding::WireType::LengthDelimited {
211 return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
212 field_number: 1u32,
213 expected: 2u8,
214 actual: tag.wire_type() as u8,
215 });
216 }
217 let mut elem = ::core::default::Default::default();
218 ::buffa::Message::merge_length_delimited(&mut elem, buf, depth)?;
219 self.file.push(elem);
220 }
221 _ => {
222 self.__buffa_unknown_fields
223 .push(::buffa::encoding::decode_unknown_field(tag, buf, depth)?);
224 }
225 }
226 ::core::result::Result::Ok(())
227 }
228 fn cached_size(&self) -> u32 {
229 self.__buffa_cached_size.get()
230 }
231 fn clear(&mut self) {
232 self.file.clear();
233 self.__buffa_unknown_fields.clear();
234 self.__buffa_cached_size.set(0);
235 }
236}
237#[derive(Clone, PartialEq, Default)]
238pub struct FileDescriptorProto {
239 pub name: Option<::buffa::alloc::string::String>,
241 pub package: Option<::buffa::alloc::string::String>,
243 pub dependency: ::buffa::alloc::vec::Vec<::buffa::alloc::string::String>,
245 pub public_dependency: ::buffa::alloc::vec::Vec<i32>,
247 pub weak_dependency: ::buffa::alloc::vec::Vec<i32>,
249 pub option_dependency: ::buffa::alloc::vec::Vec<::buffa::alloc::string::String>,
251 pub message_type: ::buffa::alloc::vec::Vec<DescriptorProto>,
253 pub enum_type: ::buffa::alloc::vec::Vec<EnumDescriptorProto>,
255 pub service: ::buffa::alloc::vec::Vec<ServiceDescriptorProto>,
257 pub extension: ::buffa::alloc::vec::Vec<FieldDescriptorProto>,
259 pub options: ::buffa::MessageField<FileOptions>,
261 pub source_code_info: ::buffa::MessageField<SourceCodeInfo>,
263 pub syntax: Option<::buffa::alloc::string::String>,
265 pub edition: Option<Edition>,
267 #[doc(hidden)]
268 pub __buffa_unknown_fields: ::buffa::UnknownFields,
269 #[doc(hidden)]
270 pub __buffa_cached_size: ::buffa::__private::CachedSize,
271}
272impl ::core::fmt::Debug for FileDescriptorProto {
273 fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
274 f.debug_struct("FileDescriptorProto")
275 .field("name", &self.name)
276 .field("package", &self.package)
277 .field("dependency", &self.dependency)
278 .field("public_dependency", &self.public_dependency)
279 .field("weak_dependency", &self.weak_dependency)
280 .field("option_dependency", &self.option_dependency)
281 .field("message_type", &self.message_type)
282 .field("enum_type", &self.enum_type)
283 .field("service", &self.service)
284 .field("extension", &self.extension)
285 .field("options", &self.options)
286 .field("source_code_info", &self.source_code_info)
287 .field("syntax", &self.syntax)
288 .field("edition", &self.edition)
289 .finish()
290 }
291}
292impl FileDescriptorProto {
293 pub const TYPE_URL: &'static str = "type.googleapis.com/google.protobuf.FileDescriptorProto";
298}
299unsafe impl ::buffa::DefaultInstance for FileDescriptorProto {
300 fn default_instance() -> &'static Self {
301 static VALUE: ::buffa::__private::OnceBox<FileDescriptorProto> = ::buffa::__private::OnceBox::new();
302 VALUE
303 .get_or_init(|| ::buffa::alloc::boxed::Box::new(
304 FileDescriptorProto::default(),
305 ))
306 }
307}
308impl ::buffa::Message for FileDescriptorProto {
309 fn compute_size(&self) -> u32 {
315 #[allow(unused_imports)]
316 use ::buffa::Enumeration as _;
317 let mut size = 0u32;
318 if let Some(ref v) = self.name {
319 size += 1u32 + ::buffa::types::string_encoded_len(v) as u32;
320 }
321 if let Some(ref v) = self.package {
322 size += 1u32 + ::buffa::types::string_encoded_len(v) as u32;
323 }
324 if self.options.is_set() {
325 let inner_size = self.options.compute_size();
326 size
327 += 1u32 + ::buffa::encoding::varint_len(inner_size as u64) as u32
328 + inner_size;
329 }
330 if self.source_code_info.is_set() {
331 let inner_size = self.source_code_info.compute_size();
332 size
333 += 1u32 + ::buffa::encoding::varint_len(inner_size as u64) as u32
334 + inner_size;
335 }
336 if let Some(ref v) = self.syntax {
337 size += 1u32 + ::buffa::types::string_encoded_len(v) as u32;
338 }
339 if let Some(ref v) = self.edition {
340 size += 1u32 + ::buffa::types::int32_encoded_len(v.to_i32()) as u32;
341 }
342 for v in &self.dependency {
343 size += 1u32 + ::buffa::types::string_encoded_len(v) as u32;
344 }
345 for v in &self.public_dependency {
346 size += 1u32 + ::buffa::types::int32_encoded_len(*v) as u32;
347 }
348 for v in &self.weak_dependency {
349 size += 1u32 + ::buffa::types::int32_encoded_len(*v) as u32;
350 }
351 for v in &self.option_dependency {
352 size += 1u32 + ::buffa::types::string_encoded_len(v) as u32;
353 }
354 for v in &self.message_type {
355 let inner_size = v.compute_size();
356 size
357 += 1u32 + ::buffa::encoding::varint_len(inner_size as u64) as u32
358 + inner_size;
359 }
360 for v in &self.enum_type {
361 let inner_size = v.compute_size();
362 size
363 += 1u32 + ::buffa::encoding::varint_len(inner_size as u64) as u32
364 + inner_size;
365 }
366 for v in &self.service {
367 let inner_size = v.compute_size();
368 size
369 += 1u32 + ::buffa::encoding::varint_len(inner_size as u64) as u32
370 + inner_size;
371 }
372 for v in &self.extension {
373 let inner_size = v.compute_size();
374 size
375 += 1u32 + ::buffa::encoding::varint_len(inner_size as u64) as u32
376 + inner_size;
377 }
378 size += self.__buffa_unknown_fields.encoded_len() as u32;
379 self.__buffa_cached_size.set(size);
380 size
381 }
382 fn write_to(&self, buf: &mut impl ::buffa::bytes::BufMut) {
383 #[allow(unused_imports)]
384 use ::buffa::Enumeration as _;
385 if let Some(ref v) = self.name {
386 ::buffa::encoding::Tag::new(
387 1u32,
388 ::buffa::encoding::WireType::LengthDelimited,
389 )
390 .encode(buf);
391 ::buffa::types::encode_string(v, buf);
392 }
393 if let Some(ref v) = self.package {
394 ::buffa::encoding::Tag::new(
395 2u32,
396 ::buffa::encoding::WireType::LengthDelimited,
397 )
398 .encode(buf);
399 ::buffa::types::encode_string(v, buf);
400 }
401 if self.options.is_set() {
402 ::buffa::encoding::Tag::new(
403 8u32,
404 ::buffa::encoding::WireType::LengthDelimited,
405 )
406 .encode(buf);
407 ::buffa::encoding::encode_varint(self.options.cached_size() as u64, buf);
408 self.options.write_to(buf);
409 }
410 if self.source_code_info.is_set() {
411 ::buffa::encoding::Tag::new(
412 9u32,
413 ::buffa::encoding::WireType::LengthDelimited,
414 )
415 .encode(buf);
416 ::buffa::encoding::encode_varint(
417 self.source_code_info.cached_size() as u64,
418 buf,
419 );
420 self.source_code_info.write_to(buf);
421 }
422 if let Some(ref v) = self.syntax {
423 ::buffa::encoding::Tag::new(
424 12u32,
425 ::buffa::encoding::WireType::LengthDelimited,
426 )
427 .encode(buf);
428 ::buffa::types::encode_string(v, buf);
429 }
430 if let Some(ref v) = self.edition {
431 ::buffa::encoding::Tag::new(14u32, ::buffa::encoding::WireType::Varint)
432 .encode(buf);
433 ::buffa::types::encode_int32(v.to_i32(), buf);
434 }
435 for v in &self.dependency {
436 ::buffa::encoding::Tag::new(
437 3u32,
438 ::buffa::encoding::WireType::LengthDelimited,
439 )
440 .encode(buf);
441 ::buffa::types::encode_string(v, buf);
442 }
443 for v in &self.public_dependency {
444 ::buffa::encoding::Tag::new(10u32, ::buffa::encoding::WireType::Varint)
445 .encode(buf);
446 ::buffa::types::encode_int32(*v, buf);
447 }
448 for v in &self.weak_dependency {
449 ::buffa::encoding::Tag::new(11u32, ::buffa::encoding::WireType::Varint)
450 .encode(buf);
451 ::buffa::types::encode_int32(*v, buf);
452 }
453 for v in &self.option_dependency {
454 ::buffa::encoding::Tag::new(
455 15u32,
456 ::buffa::encoding::WireType::LengthDelimited,
457 )
458 .encode(buf);
459 ::buffa::types::encode_string(v, buf);
460 }
461 for v in &self.message_type {
462 ::buffa::encoding::Tag::new(
463 4u32,
464 ::buffa::encoding::WireType::LengthDelimited,
465 )
466 .encode(buf);
467 ::buffa::encoding::encode_varint(v.cached_size() as u64, buf);
468 v.write_to(buf);
469 }
470 for v in &self.enum_type {
471 ::buffa::encoding::Tag::new(
472 5u32,
473 ::buffa::encoding::WireType::LengthDelimited,
474 )
475 .encode(buf);
476 ::buffa::encoding::encode_varint(v.cached_size() as u64, buf);
477 v.write_to(buf);
478 }
479 for v in &self.service {
480 ::buffa::encoding::Tag::new(
481 6u32,
482 ::buffa::encoding::WireType::LengthDelimited,
483 )
484 .encode(buf);
485 ::buffa::encoding::encode_varint(v.cached_size() as u64, buf);
486 v.write_to(buf);
487 }
488 for v in &self.extension {
489 ::buffa::encoding::Tag::new(
490 7u32,
491 ::buffa::encoding::WireType::LengthDelimited,
492 )
493 .encode(buf);
494 ::buffa::encoding::encode_varint(v.cached_size() as u64, buf);
495 v.write_to(buf);
496 }
497 self.__buffa_unknown_fields.write_to(buf);
498 }
499 fn merge_field(
500 &mut self,
501 tag: ::buffa::encoding::Tag,
502 buf: &mut impl ::buffa::bytes::Buf,
503 depth: u32,
504 ) -> ::core::result::Result<(), ::buffa::DecodeError> {
505 #[allow(unused_imports)]
506 use ::buffa::bytes::Buf as _;
507 #[allow(unused_imports)]
508 use ::buffa::Enumeration as _;
509 match tag.field_number() {
510 1u32 => {
511 if tag.wire_type() != ::buffa::encoding::WireType::LengthDelimited {
512 return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
513 field_number: 1u32,
514 expected: 2u8,
515 actual: tag.wire_type() as u8,
516 });
517 }
518 ::buffa::types::merge_string(
519 self.name.get_or_insert_with(::buffa::alloc::string::String::new),
520 buf,
521 )?;
522 }
523 2u32 => {
524 if tag.wire_type() != ::buffa::encoding::WireType::LengthDelimited {
525 return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
526 field_number: 2u32,
527 expected: 2u8,
528 actual: tag.wire_type() as u8,
529 });
530 }
531 ::buffa::types::merge_string(
532 self.package.get_or_insert_with(::buffa::alloc::string::String::new),
533 buf,
534 )?;
535 }
536 8u32 => {
537 if tag.wire_type() != ::buffa::encoding::WireType::LengthDelimited {
538 return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
539 field_number: 8u32,
540 expected: 2u8,
541 actual: tag.wire_type() as u8,
542 });
543 }
544 ::buffa::Message::merge_length_delimited(
545 self.options.get_or_insert_default(),
546 buf,
547 depth,
548 )?;
549 }
550 9u32 => {
551 if tag.wire_type() != ::buffa::encoding::WireType::LengthDelimited {
552 return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
553 field_number: 9u32,
554 expected: 2u8,
555 actual: tag.wire_type() as u8,
556 });
557 }
558 ::buffa::Message::merge_length_delimited(
559 self.source_code_info.get_or_insert_default(),
560 buf,
561 depth,
562 )?;
563 }
564 12u32 => {
565 if tag.wire_type() != ::buffa::encoding::WireType::LengthDelimited {
566 return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
567 field_number: 12u32,
568 expected: 2u8,
569 actual: tag.wire_type() as u8,
570 });
571 }
572 ::buffa::types::merge_string(
573 self.syntax.get_or_insert_with(::buffa::alloc::string::String::new),
574 buf,
575 )?;
576 }
577 14u32 => {
578 if tag.wire_type() != ::buffa::encoding::WireType::Varint {
579 return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
580 field_number: 14u32,
581 expected: 0u8,
582 actual: tag.wire_type() as u8,
583 });
584 }
585 let __raw = ::buffa::types::decode_int32(buf)?;
586 if let ::core::option::Option::Some(__v) = ::buffa::Enumeration::from_i32(
587 __raw,
588 ) {
589 self.edition = ::core::option::Option::Some(__v);
590 } else {
591 self.__buffa_unknown_fields
592 .push(::buffa::UnknownField {
593 number: 14u32,
594 data: ::buffa::UnknownFieldData::Varint(__raw as u64),
595 });
596 }
597 }
598 3u32 => {
599 if tag.wire_type() != ::buffa::encoding::WireType::LengthDelimited {
600 return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
601 field_number: 3u32,
602 expected: 2u8,
603 actual: tag.wire_type() as u8,
604 });
605 }
606 self.dependency.push(::buffa::types::decode_string(buf)?);
607 }
608 10u32 => {
609 if tag.wire_type() == ::buffa::encoding::WireType::LengthDelimited {
610 let len = ::buffa::encoding::decode_varint(buf)?;
611 let len = usize::try_from(len)
612 .map_err(|_| ::buffa::DecodeError::MessageTooLarge)?;
613 if buf.remaining() < len {
614 return ::core::result::Result::Err(
615 ::buffa::DecodeError::UnexpectedEof,
616 );
617 }
618 self.public_dependency.reserve(len);
619 let mut limited = buf.take(len);
620 while limited.has_remaining() {
621 self.public_dependency
622 .push(::buffa::types::decode_int32(&mut limited)?);
623 }
624 let leftover = limited.remaining();
625 if leftover > 0 {
626 limited.advance(leftover);
627 }
628 } else if tag.wire_type() == ::buffa::encoding::WireType::Varint {
629 self.public_dependency.push(::buffa::types::decode_int32(buf)?);
630 } else {
631 return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
632 field_number: 10u32,
633 expected: 2u8,
634 actual: tag.wire_type() as u8,
635 });
636 }
637 }
638 11u32 => {
639 if tag.wire_type() == ::buffa::encoding::WireType::LengthDelimited {
640 let len = ::buffa::encoding::decode_varint(buf)?;
641 let len = usize::try_from(len)
642 .map_err(|_| ::buffa::DecodeError::MessageTooLarge)?;
643 if buf.remaining() < len {
644 return ::core::result::Result::Err(
645 ::buffa::DecodeError::UnexpectedEof,
646 );
647 }
648 self.weak_dependency.reserve(len);
649 let mut limited = buf.take(len);
650 while limited.has_remaining() {
651 self.weak_dependency
652 .push(::buffa::types::decode_int32(&mut limited)?);
653 }
654 let leftover = limited.remaining();
655 if leftover > 0 {
656 limited.advance(leftover);
657 }
658 } else if tag.wire_type() == ::buffa::encoding::WireType::Varint {
659 self.weak_dependency.push(::buffa::types::decode_int32(buf)?);
660 } else {
661 return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
662 field_number: 11u32,
663 expected: 2u8,
664 actual: tag.wire_type() as u8,
665 });
666 }
667 }
668 15u32 => {
669 if tag.wire_type() != ::buffa::encoding::WireType::LengthDelimited {
670 return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
671 field_number: 15u32,
672 expected: 2u8,
673 actual: tag.wire_type() as u8,
674 });
675 }
676 self.option_dependency.push(::buffa::types::decode_string(buf)?);
677 }
678 4u32 => {
679 if tag.wire_type() != ::buffa::encoding::WireType::LengthDelimited {
680 return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
681 field_number: 4u32,
682 expected: 2u8,
683 actual: tag.wire_type() as u8,
684 });
685 }
686 let mut elem = ::core::default::Default::default();
687 ::buffa::Message::merge_length_delimited(&mut elem, buf, depth)?;
688 self.message_type.push(elem);
689 }
690 5u32 => {
691 if tag.wire_type() != ::buffa::encoding::WireType::LengthDelimited {
692 return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
693 field_number: 5u32,
694 expected: 2u8,
695 actual: tag.wire_type() as u8,
696 });
697 }
698 let mut elem = ::core::default::Default::default();
699 ::buffa::Message::merge_length_delimited(&mut elem, buf, depth)?;
700 self.enum_type.push(elem);
701 }
702 6u32 => {
703 if tag.wire_type() != ::buffa::encoding::WireType::LengthDelimited {
704 return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
705 field_number: 6u32,
706 expected: 2u8,
707 actual: tag.wire_type() as u8,
708 });
709 }
710 let mut elem = ::core::default::Default::default();
711 ::buffa::Message::merge_length_delimited(&mut elem, buf, depth)?;
712 self.service.push(elem);
713 }
714 7u32 => {
715 if tag.wire_type() != ::buffa::encoding::WireType::LengthDelimited {
716 return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
717 field_number: 7u32,
718 expected: 2u8,
719 actual: tag.wire_type() as u8,
720 });
721 }
722 let mut elem = ::core::default::Default::default();
723 ::buffa::Message::merge_length_delimited(&mut elem, buf, depth)?;
724 self.extension.push(elem);
725 }
726 _ => {
727 self.__buffa_unknown_fields
728 .push(::buffa::encoding::decode_unknown_field(tag, buf, depth)?);
729 }
730 }
731 ::core::result::Result::Ok(())
732 }
733 fn cached_size(&self) -> u32 {
734 self.__buffa_cached_size.get()
735 }
736 fn clear(&mut self) {
737 self.name = ::core::option::Option::None;
738 self.package = ::core::option::Option::None;
739 self.options = ::buffa::MessageField::none();
740 self.source_code_info = ::buffa::MessageField::none();
741 self.syntax = ::core::option::Option::None;
742 self.edition = ::core::option::Option::None;
743 self.dependency.clear();
744 self.public_dependency.clear();
745 self.weak_dependency.clear();
746 self.option_dependency.clear();
747 self.message_type.clear();
748 self.enum_type.clear();
749 self.service.clear();
750 self.extension.clear();
751 self.__buffa_unknown_fields.clear();
752 self.__buffa_cached_size.set(0);
753 }
754}
755#[derive(Clone, PartialEq, Default)]
756pub struct DescriptorProto {
757 pub name: Option<::buffa::alloc::string::String>,
759 pub field: ::buffa::alloc::vec::Vec<FieldDescriptorProto>,
761 pub extension: ::buffa::alloc::vec::Vec<FieldDescriptorProto>,
763 pub nested_type: ::buffa::alloc::vec::Vec<DescriptorProto>,
765 pub enum_type: ::buffa::alloc::vec::Vec<EnumDescriptorProto>,
767 pub extension_range: ::buffa::alloc::vec::Vec<descriptor_proto::ExtensionRange>,
769 pub oneof_decl: ::buffa::alloc::vec::Vec<OneofDescriptorProto>,
771 pub options: ::buffa::MessageField<MessageOptions>,
773 pub reserved_range: ::buffa::alloc::vec::Vec<descriptor_proto::ReservedRange>,
775 pub reserved_name: ::buffa::alloc::vec::Vec<::buffa::alloc::string::String>,
777 pub visibility: Option<SymbolVisibility>,
779 #[doc(hidden)]
780 pub __buffa_unknown_fields: ::buffa::UnknownFields,
781 #[doc(hidden)]
782 pub __buffa_cached_size: ::buffa::__private::CachedSize,
783}
784impl ::core::fmt::Debug for DescriptorProto {
785 fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
786 f.debug_struct("DescriptorProto")
787 .field("name", &self.name)
788 .field("field", &self.field)
789 .field("extension", &self.extension)
790 .field("nested_type", &self.nested_type)
791 .field("enum_type", &self.enum_type)
792 .field("extension_range", &self.extension_range)
793 .field("oneof_decl", &self.oneof_decl)
794 .field("options", &self.options)
795 .field("reserved_range", &self.reserved_range)
796 .field("reserved_name", &self.reserved_name)
797 .field("visibility", &self.visibility)
798 .finish()
799 }
800}
801impl DescriptorProto {
802 pub const TYPE_URL: &'static str = "type.googleapis.com/google.protobuf.DescriptorProto";
807}
808unsafe impl ::buffa::DefaultInstance for DescriptorProto {
809 fn default_instance() -> &'static Self {
810 static VALUE: ::buffa::__private::OnceBox<DescriptorProto> = ::buffa::__private::OnceBox::new();
811 VALUE.get_or_init(|| ::buffa::alloc::boxed::Box::new(DescriptorProto::default()))
812 }
813}
814impl ::buffa::Message for DescriptorProto {
815 fn compute_size(&self) -> u32 {
821 #[allow(unused_imports)]
822 use ::buffa::Enumeration as _;
823 let mut size = 0u32;
824 if let Some(ref v) = self.name {
825 size += 1u32 + ::buffa::types::string_encoded_len(v) as u32;
826 }
827 if self.options.is_set() {
828 let inner_size = self.options.compute_size();
829 size
830 += 1u32 + ::buffa::encoding::varint_len(inner_size as u64) as u32
831 + inner_size;
832 }
833 if let Some(ref v) = self.visibility {
834 size += 1u32 + ::buffa::types::int32_encoded_len(v.to_i32()) as u32;
835 }
836 for v in &self.field {
837 let inner_size = v.compute_size();
838 size
839 += 1u32 + ::buffa::encoding::varint_len(inner_size as u64) as u32
840 + inner_size;
841 }
842 for v in &self.extension {
843 let inner_size = v.compute_size();
844 size
845 += 1u32 + ::buffa::encoding::varint_len(inner_size as u64) as u32
846 + inner_size;
847 }
848 for v in &self.nested_type {
849 let inner_size = v.compute_size();
850 size
851 += 1u32 + ::buffa::encoding::varint_len(inner_size as u64) as u32
852 + inner_size;
853 }
854 for v in &self.enum_type {
855 let inner_size = v.compute_size();
856 size
857 += 1u32 + ::buffa::encoding::varint_len(inner_size as u64) as u32
858 + inner_size;
859 }
860 for v in &self.extension_range {
861 let inner_size = v.compute_size();
862 size
863 += 1u32 + ::buffa::encoding::varint_len(inner_size as u64) as u32
864 + inner_size;
865 }
866 for v in &self.oneof_decl {
867 let inner_size = v.compute_size();
868 size
869 += 1u32 + ::buffa::encoding::varint_len(inner_size as u64) as u32
870 + inner_size;
871 }
872 for v in &self.reserved_range {
873 let inner_size = v.compute_size();
874 size
875 += 1u32 + ::buffa::encoding::varint_len(inner_size as u64) as u32
876 + inner_size;
877 }
878 for v in &self.reserved_name {
879 size += 1u32 + ::buffa::types::string_encoded_len(v) as u32;
880 }
881 size += self.__buffa_unknown_fields.encoded_len() as u32;
882 self.__buffa_cached_size.set(size);
883 size
884 }
885 fn write_to(&self, buf: &mut impl ::buffa::bytes::BufMut) {
886 #[allow(unused_imports)]
887 use ::buffa::Enumeration as _;
888 if let Some(ref v) = self.name {
889 ::buffa::encoding::Tag::new(
890 1u32,
891 ::buffa::encoding::WireType::LengthDelimited,
892 )
893 .encode(buf);
894 ::buffa::types::encode_string(v, buf);
895 }
896 if self.options.is_set() {
897 ::buffa::encoding::Tag::new(
898 7u32,
899 ::buffa::encoding::WireType::LengthDelimited,
900 )
901 .encode(buf);
902 ::buffa::encoding::encode_varint(self.options.cached_size() as u64, buf);
903 self.options.write_to(buf);
904 }
905 if let Some(ref v) = self.visibility {
906 ::buffa::encoding::Tag::new(11u32, ::buffa::encoding::WireType::Varint)
907 .encode(buf);
908 ::buffa::types::encode_int32(v.to_i32(), buf);
909 }
910 for v in &self.field {
911 ::buffa::encoding::Tag::new(
912 2u32,
913 ::buffa::encoding::WireType::LengthDelimited,
914 )
915 .encode(buf);
916 ::buffa::encoding::encode_varint(v.cached_size() as u64, buf);
917 v.write_to(buf);
918 }
919 for v in &self.extension {
920 ::buffa::encoding::Tag::new(
921 6u32,
922 ::buffa::encoding::WireType::LengthDelimited,
923 )
924 .encode(buf);
925 ::buffa::encoding::encode_varint(v.cached_size() as u64, buf);
926 v.write_to(buf);
927 }
928 for v in &self.nested_type {
929 ::buffa::encoding::Tag::new(
930 3u32,
931 ::buffa::encoding::WireType::LengthDelimited,
932 )
933 .encode(buf);
934 ::buffa::encoding::encode_varint(v.cached_size() as u64, buf);
935 v.write_to(buf);
936 }
937 for v in &self.enum_type {
938 ::buffa::encoding::Tag::new(
939 4u32,
940 ::buffa::encoding::WireType::LengthDelimited,
941 )
942 .encode(buf);
943 ::buffa::encoding::encode_varint(v.cached_size() as u64, buf);
944 v.write_to(buf);
945 }
946 for v in &self.extension_range {
947 ::buffa::encoding::Tag::new(
948 5u32,
949 ::buffa::encoding::WireType::LengthDelimited,
950 )
951 .encode(buf);
952 ::buffa::encoding::encode_varint(v.cached_size() as u64, buf);
953 v.write_to(buf);
954 }
955 for v in &self.oneof_decl {
956 ::buffa::encoding::Tag::new(
957 8u32,
958 ::buffa::encoding::WireType::LengthDelimited,
959 )
960 .encode(buf);
961 ::buffa::encoding::encode_varint(v.cached_size() as u64, buf);
962 v.write_to(buf);
963 }
964 for v in &self.reserved_range {
965 ::buffa::encoding::Tag::new(
966 9u32,
967 ::buffa::encoding::WireType::LengthDelimited,
968 )
969 .encode(buf);
970 ::buffa::encoding::encode_varint(v.cached_size() as u64, buf);
971 v.write_to(buf);
972 }
973 for v in &self.reserved_name {
974 ::buffa::encoding::Tag::new(
975 10u32,
976 ::buffa::encoding::WireType::LengthDelimited,
977 )
978 .encode(buf);
979 ::buffa::types::encode_string(v, buf);
980 }
981 self.__buffa_unknown_fields.write_to(buf);
982 }
983 fn merge_field(
984 &mut self,
985 tag: ::buffa::encoding::Tag,
986 buf: &mut impl ::buffa::bytes::Buf,
987 depth: u32,
988 ) -> ::core::result::Result<(), ::buffa::DecodeError> {
989 #[allow(unused_imports)]
990 use ::buffa::bytes::Buf as _;
991 #[allow(unused_imports)]
992 use ::buffa::Enumeration as _;
993 match tag.field_number() {
994 1u32 => {
995 if tag.wire_type() != ::buffa::encoding::WireType::LengthDelimited {
996 return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
997 field_number: 1u32,
998 expected: 2u8,
999 actual: tag.wire_type() as u8,
1000 });
1001 }
1002 ::buffa::types::merge_string(
1003 self.name.get_or_insert_with(::buffa::alloc::string::String::new),
1004 buf,
1005 )?;
1006 }
1007 7u32 => {
1008 if tag.wire_type() != ::buffa::encoding::WireType::LengthDelimited {
1009 return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
1010 field_number: 7u32,
1011 expected: 2u8,
1012 actual: tag.wire_type() as u8,
1013 });
1014 }
1015 ::buffa::Message::merge_length_delimited(
1016 self.options.get_or_insert_default(),
1017 buf,
1018 depth,
1019 )?;
1020 }
1021 11u32 => {
1022 if tag.wire_type() != ::buffa::encoding::WireType::Varint {
1023 return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
1024 field_number: 11u32,
1025 expected: 0u8,
1026 actual: tag.wire_type() as u8,
1027 });
1028 }
1029 let __raw = ::buffa::types::decode_int32(buf)?;
1030 if let ::core::option::Option::Some(__v) = ::buffa::Enumeration::from_i32(
1031 __raw,
1032 ) {
1033 self.visibility = ::core::option::Option::Some(__v);
1034 } else {
1035 self.__buffa_unknown_fields
1036 .push(::buffa::UnknownField {
1037 number: 11u32,
1038 data: ::buffa::UnknownFieldData::Varint(__raw as u64),
1039 });
1040 }
1041 }
1042 2u32 => {
1043 if tag.wire_type() != ::buffa::encoding::WireType::LengthDelimited {
1044 return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
1045 field_number: 2u32,
1046 expected: 2u8,
1047 actual: tag.wire_type() as u8,
1048 });
1049 }
1050 let mut elem = ::core::default::Default::default();
1051 ::buffa::Message::merge_length_delimited(&mut elem, buf, depth)?;
1052 self.field.push(elem);
1053 }
1054 6u32 => {
1055 if tag.wire_type() != ::buffa::encoding::WireType::LengthDelimited {
1056 return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
1057 field_number: 6u32,
1058 expected: 2u8,
1059 actual: tag.wire_type() as u8,
1060 });
1061 }
1062 let mut elem = ::core::default::Default::default();
1063 ::buffa::Message::merge_length_delimited(&mut elem, buf, depth)?;
1064 self.extension.push(elem);
1065 }
1066 3u32 => {
1067 if tag.wire_type() != ::buffa::encoding::WireType::LengthDelimited {
1068 return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
1069 field_number: 3u32,
1070 expected: 2u8,
1071 actual: tag.wire_type() as u8,
1072 });
1073 }
1074 let mut elem = ::core::default::Default::default();
1075 ::buffa::Message::merge_length_delimited(&mut elem, buf, depth)?;
1076 self.nested_type.push(elem);
1077 }
1078 4u32 => {
1079 if tag.wire_type() != ::buffa::encoding::WireType::LengthDelimited {
1080 return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
1081 field_number: 4u32,
1082 expected: 2u8,
1083 actual: tag.wire_type() as u8,
1084 });
1085 }
1086 let mut elem = ::core::default::Default::default();
1087 ::buffa::Message::merge_length_delimited(&mut elem, buf, depth)?;
1088 self.enum_type.push(elem);
1089 }
1090 5u32 => {
1091 if tag.wire_type() != ::buffa::encoding::WireType::LengthDelimited {
1092 return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
1093 field_number: 5u32,
1094 expected: 2u8,
1095 actual: tag.wire_type() as u8,
1096 });
1097 }
1098 let mut elem = ::core::default::Default::default();
1099 ::buffa::Message::merge_length_delimited(&mut elem, buf, depth)?;
1100 self.extension_range.push(elem);
1101 }
1102 8u32 => {
1103 if tag.wire_type() != ::buffa::encoding::WireType::LengthDelimited {
1104 return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
1105 field_number: 8u32,
1106 expected: 2u8,
1107 actual: tag.wire_type() as u8,
1108 });
1109 }
1110 let mut elem = ::core::default::Default::default();
1111 ::buffa::Message::merge_length_delimited(&mut elem, buf, depth)?;
1112 self.oneof_decl.push(elem);
1113 }
1114 9u32 => {
1115 if tag.wire_type() != ::buffa::encoding::WireType::LengthDelimited {
1116 return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
1117 field_number: 9u32,
1118 expected: 2u8,
1119 actual: tag.wire_type() as u8,
1120 });
1121 }
1122 let mut elem = ::core::default::Default::default();
1123 ::buffa::Message::merge_length_delimited(&mut elem, buf, depth)?;
1124 self.reserved_range.push(elem);
1125 }
1126 10u32 => {
1127 if tag.wire_type() != ::buffa::encoding::WireType::LengthDelimited {
1128 return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
1129 field_number: 10u32,
1130 expected: 2u8,
1131 actual: tag.wire_type() as u8,
1132 });
1133 }
1134 self.reserved_name.push(::buffa::types::decode_string(buf)?);
1135 }
1136 _ => {
1137 self.__buffa_unknown_fields
1138 .push(::buffa::encoding::decode_unknown_field(tag, buf, depth)?);
1139 }
1140 }
1141 ::core::result::Result::Ok(())
1142 }
1143 fn cached_size(&self) -> u32 {
1144 self.__buffa_cached_size.get()
1145 }
1146 fn clear(&mut self) {
1147 self.name = ::core::option::Option::None;
1148 self.options = ::buffa::MessageField::none();
1149 self.visibility = ::core::option::Option::None;
1150 self.field.clear();
1151 self.extension.clear();
1152 self.nested_type.clear();
1153 self.enum_type.clear();
1154 self.extension_range.clear();
1155 self.oneof_decl.clear();
1156 self.reserved_range.clear();
1157 self.reserved_name.clear();
1158 self.__buffa_unknown_fields.clear();
1159 self.__buffa_cached_size.set(0);
1160 }
1161}
1162pub mod descriptor_proto {
1163 #[allow(unused_imports)]
1164 use super::*;
1165 #[derive(Clone, PartialEq, Default)]
1166 pub struct ExtensionRange {
1167 pub start: Option<i32>,
1169 pub end: Option<i32>,
1171 pub options: ::buffa::MessageField<ExtensionRangeOptions>,
1173 #[doc(hidden)]
1174 pub __buffa_unknown_fields: ::buffa::UnknownFields,
1175 #[doc(hidden)]
1176 pub __buffa_cached_size: ::buffa::__private::CachedSize,
1177 }
1178 impl ::core::fmt::Debug for ExtensionRange {
1179 fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
1180 f.debug_struct("ExtensionRange")
1181 .field("start", &self.start)
1182 .field("end", &self.end)
1183 .field("options", &self.options)
1184 .finish()
1185 }
1186 }
1187 impl ExtensionRange {
1188 pub const TYPE_URL: &'static str = "type.googleapis.com/google.protobuf.DescriptorProto.ExtensionRange";
1193 }
1194 unsafe impl ::buffa::DefaultInstance for ExtensionRange {
1195 fn default_instance() -> &'static Self {
1196 static VALUE: ::buffa::__private::OnceBox<ExtensionRange> = ::buffa::__private::OnceBox::new();
1197 VALUE
1198 .get_or_init(|| ::buffa::alloc::boxed::Box::new(
1199 ExtensionRange::default(),
1200 ))
1201 }
1202 }
1203 impl ::buffa::Message for ExtensionRange {
1204 fn compute_size(&self) -> u32 {
1210 #[allow(unused_imports)]
1211 use ::buffa::Enumeration as _;
1212 let mut size = 0u32;
1213 if let Some(v) = self.start {
1214 size += 1u32 + ::buffa::types::int32_encoded_len(v) as u32;
1215 }
1216 if let Some(v) = self.end {
1217 size += 1u32 + ::buffa::types::int32_encoded_len(v) as u32;
1218 }
1219 if self.options.is_set() {
1220 let inner_size = self.options.compute_size();
1221 size
1222 += 1u32 + ::buffa::encoding::varint_len(inner_size as u64) as u32
1223 + inner_size;
1224 }
1225 size += self.__buffa_unknown_fields.encoded_len() as u32;
1226 self.__buffa_cached_size.set(size);
1227 size
1228 }
1229 fn write_to(&self, buf: &mut impl ::buffa::bytes::BufMut) {
1230 #[allow(unused_imports)]
1231 use ::buffa::Enumeration as _;
1232 if let Some(v) = self.start {
1233 ::buffa::encoding::Tag::new(1u32, ::buffa::encoding::WireType::Varint)
1234 .encode(buf);
1235 ::buffa::types::encode_int32(v, buf);
1236 }
1237 if let Some(v) = self.end {
1238 ::buffa::encoding::Tag::new(2u32, ::buffa::encoding::WireType::Varint)
1239 .encode(buf);
1240 ::buffa::types::encode_int32(v, buf);
1241 }
1242 if self.options.is_set() {
1243 ::buffa::encoding::Tag::new(
1244 3u32,
1245 ::buffa::encoding::WireType::LengthDelimited,
1246 )
1247 .encode(buf);
1248 ::buffa::encoding::encode_varint(self.options.cached_size() as u64, buf);
1249 self.options.write_to(buf);
1250 }
1251 self.__buffa_unknown_fields.write_to(buf);
1252 }
1253 fn merge_field(
1254 &mut self,
1255 tag: ::buffa::encoding::Tag,
1256 buf: &mut impl ::buffa::bytes::Buf,
1257 depth: u32,
1258 ) -> ::core::result::Result<(), ::buffa::DecodeError> {
1259 #[allow(unused_imports)]
1260 use ::buffa::bytes::Buf as _;
1261 #[allow(unused_imports)]
1262 use ::buffa::Enumeration as _;
1263 match tag.field_number() {
1264 1u32 => {
1265 if tag.wire_type() != ::buffa::encoding::WireType::Varint {
1266 return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
1267 field_number: 1u32,
1268 expected: 0u8,
1269 actual: tag.wire_type() as u8,
1270 });
1271 }
1272 self.start = ::core::option::Option::Some(
1273 ::buffa::types::decode_int32(buf)?,
1274 );
1275 }
1276 2u32 => {
1277 if tag.wire_type() != ::buffa::encoding::WireType::Varint {
1278 return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
1279 field_number: 2u32,
1280 expected: 0u8,
1281 actual: tag.wire_type() as u8,
1282 });
1283 }
1284 self.end = ::core::option::Option::Some(
1285 ::buffa::types::decode_int32(buf)?,
1286 );
1287 }
1288 3u32 => {
1289 if tag.wire_type() != ::buffa::encoding::WireType::LengthDelimited {
1290 return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
1291 field_number: 3u32,
1292 expected: 2u8,
1293 actual: tag.wire_type() as u8,
1294 });
1295 }
1296 ::buffa::Message::merge_length_delimited(
1297 self.options.get_or_insert_default(),
1298 buf,
1299 depth,
1300 )?;
1301 }
1302 _ => {
1303 self.__buffa_unknown_fields
1304 .push(::buffa::encoding::decode_unknown_field(tag, buf, depth)?);
1305 }
1306 }
1307 ::core::result::Result::Ok(())
1308 }
1309 fn cached_size(&self) -> u32 {
1310 self.__buffa_cached_size.get()
1311 }
1312 fn clear(&mut self) {
1313 self.start = ::core::option::Option::None;
1314 self.end = ::core::option::Option::None;
1315 self.options = ::buffa::MessageField::none();
1316 self.__buffa_unknown_fields.clear();
1317 self.__buffa_cached_size.set(0);
1318 }
1319 }
1320 #[derive(Clone, PartialEq, Default)]
1321 pub struct ReservedRange {
1322 pub start: Option<i32>,
1324 pub end: Option<i32>,
1326 #[doc(hidden)]
1327 pub __buffa_unknown_fields: ::buffa::UnknownFields,
1328 #[doc(hidden)]
1329 pub __buffa_cached_size: ::buffa::__private::CachedSize,
1330 }
1331 impl ::core::fmt::Debug for ReservedRange {
1332 fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
1333 f.debug_struct("ReservedRange")
1334 .field("start", &self.start)
1335 .field("end", &self.end)
1336 .finish()
1337 }
1338 }
1339 impl ReservedRange {
1340 pub const TYPE_URL: &'static str = "type.googleapis.com/google.protobuf.DescriptorProto.ReservedRange";
1345 }
1346 unsafe impl ::buffa::DefaultInstance for ReservedRange {
1347 fn default_instance() -> &'static Self {
1348 static VALUE: ::buffa::__private::OnceBox<ReservedRange> = ::buffa::__private::OnceBox::new();
1349 VALUE
1350 .get_or_init(|| ::buffa::alloc::boxed::Box::new(
1351 ReservedRange::default(),
1352 ))
1353 }
1354 }
1355 impl ::buffa::Message for ReservedRange {
1356 fn compute_size(&self) -> u32 {
1362 #[allow(unused_imports)]
1363 use ::buffa::Enumeration as _;
1364 let mut size = 0u32;
1365 if let Some(v) = self.start {
1366 size += 1u32 + ::buffa::types::int32_encoded_len(v) as u32;
1367 }
1368 if let Some(v) = self.end {
1369 size += 1u32 + ::buffa::types::int32_encoded_len(v) as u32;
1370 }
1371 size += self.__buffa_unknown_fields.encoded_len() as u32;
1372 self.__buffa_cached_size.set(size);
1373 size
1374 }
1375 fn write_to(&self, buf: &mut impl ::buffa::bytes::BufMut) {
1376 #[allow(unused_imports)]
1377 use ::buffa::Enumeration as _;
1378 if let Some(v) = self.start {
1379 ::buffa::encoding::Tag::new(1u32, ::buffa::encoding::WireType::Varint)
1380 .encode(buf);
1381 ::buffa::types::encode_int32(v, buf);
1382 }
1383 if let Some(v) = self.end {
1384 ::buffa::encoding::Tag::new(2u32, ::buffa::encoding::WireType::Varint)
1385 .encode(buf);
1386 ::buffa::types::encode_int32(v, buf);
1387 }
1388 self.__buffa_unknown_fields.write_to(buf);
1389 }
1390 fn merge_field(
1391 &mut self,
1392 tag: ::buffa::encoding::Tag,
1393 buf: &mut impl ::buffa::bytes::Buf,
1394 depth: u32,
1395 ) -> ::core::result::Result<(), ::buffa::DecodeError> {
1396 #[allow(unused_imports)]
1397 use ::buffa::bytes::Buf as _;
1398 #[allow(unused_imports)]
1399 use ::buffa::Enumeration as _;
1400 match tag.field_number() {
1401 1u32 => {
1402 if tag.wire_type() != ::buffa::encoding::WireType::Varint {
1403 return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
1404 field_number: 1u32,
1405 expected: 0u8,
1406 actual: tag.wire_type() as u8,
1407 });
1408 }
1409 self.start = ::core::option::Option::Some(
1410 ::buffa::types::decode_int32(buf)?,
1411 );
1412 }
1413 2u32 => {
1414 if tag.wire_type() != ::buffa::encoding::WireType::Varint {
1415 return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
1416 field_number: 2u32,
1417 expected: 0u8,
1418 actual: tag.wire_type() as u8,
1419 });
1420 }
1421 self.end = ::core::option::Option::Some(
1422 ::buffa::types::decode_int32(buf)?,
1423 );
1424 }
1425 _ => {
1426 self.__buffa_unknown_fields
1427 .push(::buffa::encoding::decode_unknown_field(tag, buf, depth)?);
1428 }
1429 }
1430 ::core::result::Result::Ok(())
1431 }
1432 fn cached_size(&self) -> u32 {
1433 self.__buffa_cached_size.get()
1434 }
1435 fn clear(&mut self) {
1436 self.start = ::core::option::Option::None;
1437 self.end = ::core::option::Option::None;
1438 self.__buffa_unknown_fields.clear();
1439 self.__buffa_cached_size.set(0);
1440 }
1441 }
1442}
1443#[derive(Clone, PartialEq, Default)]
1444pub struct ExtensionRangeOptions {
1445 pub uninterpreted_option: ::buffa::alloc::vec::Vec<UninterpretedOption>,
1447 pub declaration: ::buffa::alloc::vec::Vec<extension_range_options::Declaration>,
1449 pub features: ::buffa::MessageField<FeatureSet>,
1451 pub verification: Option<extension_range_options::VerificationState>,
1453 #[doc(hidden)]
1454 pub __buffa_unknown_fields: ::buffa::UnknownFields,
1455 #[doc(hidden)]
1456 pub __buffa_cached_size: ::buffa::__private::CachedSize,
1457}
1458impl ::core::fmt::Debug for ExtensionRangeOptions {
1459 fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
1460 f.debug_struct("ExtensionRangeOptions")
1461 .field("uninterpreted_option", &self.uninterpreted_option)
1462 .field("declaration", &self.declaration)
1463 .field("features", &self.features)
1464 .field("verification", &self.verification)
1465 .finish()
1466 }
1467}
1468impl ExtensionRangeOptions {
1469 pub const TYPE_URL: &'static str = "type.googleapis.com/google.protobuf.ExtensionRangeOptions";
1474}
1475unsafe impl ::buffa::DefaultInstance for ExtensionRangeOptions {
1476 fn default_instance() -> &'static Self {
1477 static VALUE: ::buffa::__private::OnceBox<ExtensionRangeOptions> = ::buffa::__private::OnceBox::new();
1478 VALUE
1479 .get_or_init(|| ::buffa::alloc::boxed::Box::new(
1480 ExtensionRangeOptions::default(),
1481 ))
1482 }
1483}
1484impl ::buffa::Message for ExtensionRangeOptions {
1485 fn compute_size(&self) -> u32 {
1491 #[allow(unused_imports)]
1492 use ::buffa::Enumeration as _;
1493 let mut size = 0u32;
1494 if self.features.is_set() {
1495 let inner_size = self.features.compute_size();
1496 size
1497 += 2u32 + ::buffa::encoding::varint_len(inner_size as u64) as u32
1498 + inner_size;
1499 }
1500 if let Some(ref v) = self.verification {
1501 size += 1u32 + ::buffa::types::int32_encoded_len(v.to_i32()) as u32;
1502 }
1503 for v in &self.uninterpreted_option {
1504 let inner_size = v.compute_size();
1505 size
1506 += 2u32 + ::buffa::encoding::varint_len(inner_size as u64) as u32
1507 + inner_size;
1508 }
1509 for v in &self.declaration {
1510 let inner_size = v.compute_size();
1511 size
1512 += 1u32 + ::buffa::encoding::varint_len(inner_size as u64) as u32
1513 + inner_size;
1514 }
1515 size += self.__buffa_unknown_fields.encoded_len() as u32;
1516 self.__buffa_cached_size.set(size);
1517 size
1518 }
1519 fn write_to(&self, buf: &mut impl ::buffa::bytes::BufMut) {
1520 #[allow(unused_imports)]
1521 use ::buffa::Enumeration as _;
1522 if self.features.is_set() {
1523 ::buffa::encoding::Tag::new(
1524 50u32,
1525 ::buffa::encoding::WireType::LengthDelimited,
1526 )
1527 .encode(buf);
1528 ::buffa::encoding::encode_varint(self.features.cached_size() as u64, buf);
1529 self.features.write_to(buf);
1530 }
1531 if let Some(ref v) = self.verification {
1532 ::buffa::encoding::Tag::new(3u32, ::buffa::encoding::WireType::Varint)
1533 .encode(buf);
1534 ::buffa::types::encode_int32(v.to_i32(), buf);
1535 }
1536 for v in &self.uninterpreted_option {
1537 ::buffa::encoding::Tag::new(
1538 999u32,
1539 ::buffa::encoding::WireType::LengthDelimited,
1540 )
1541 .encode(buf);
1542 ::buffa::encoding::encode_varint(v.cached_size() as u64, buf);
1543 v.write_to(buf);
1544 }
1545 for v in &self.declaration {
1546 ::buffa::encoding::Tag::new(
1547 2u32,
1548 ::buffa::encoding::WireType::LengthDelimited,
1549 )
1550 .encode(buf);
1551 ::buffa::encoding::encode_varint(v.cached_size() as u64, buf);
1552 v.write_to(buf);
1553 }
1554 self.__buffa_unknown_fields.write_to(buf);
1555 }
1556 fn merge_field(
1557 &mut self,
1558 tag: ::buffa::encoding::Tag,
1559 buf: &mut impl ::buffa::bytes::Buf,
1560 depth: u32,
1561 ) -> ::core::result::Result<(), ::buffa::DecodeError> {
1562 #[allow(unused_imports)]
1563 use ::buffa::bytes::Buf as _;
1564 #[allow(unused_imports)]
1565 use ::buffa::Enumeration as _;
1566 match tag.field_number() {
1567 50u32 => {
1568 if tag.wire_type() != ::buffa::encoding::WireType::LengthDelimited {
1569 return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
1570 field_number: 50u32,
1571 expected: 2u8,
1572 actual: tag.wire_type() as u8,
1573 });
1574 }
1575 ::buffa::Message::merge_length_delimited(
1576 self.features.get_or_insert_default(),
1577 buf,
1578 depth,
1579 )?;
1580 }
1581 3u32 => {
1582 if tag.wire_type() != ::buffa::encoding::WireType::Varint {
1583 return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
1584 field_number: 3u32,
1585 expected: 0u8,
1586 actual: tag.wire_type() as u8,
1587 });
1588 }
1589 let __raw = ::buffa::types::decode_int32(buf)?;
1590 if let ::core::option::Option::Some(__v) = ::buffa::Enumeration::from_i32(
1591 __raw,
1592 ) {
1593 self.verification = ::core::option::Option::Some(__v);
1594 } else {
1595 self.__buffa_unknown_fields
1596 .push(::buffa::UnknownField {
1597 number: 3u32,
1598 data: ::buffa::UnknownFieldData::Varint(__raw as u64),
1599 });
1600 }
1601 }
1602 999u32 => {
1603 if tag.wire_type() != ::buffa::encoding::WireType::LengthDelimited {
1604 return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
1605 field_number: 999u32,
1606 expected: 2u8,
1607 actual: tag.wire_type() as u8,
1608 });
1609 }
1610 let mut elem = ::core::default::Default::default();
1611 ::buffa::Message::merge_length_delimited(&mut elem, buf, depth)?;
1612 self.uninterpreted_option.push(elem);
1613 }
1614 2u32 => {
1615 if tag.wire_type() != ::buffa::encoding::WireType::LengthDelimited {
1616 return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
1617 field_number: 2u32,
1618 expected: 2u8,
1619 actual: tag.wire_type() as u8,
1620 });
1621 }
1622 let mut elem = ::core::default::Default::default();
1623 ::buffa::Message::merge_length_delimited(&mut elem, buf, depth)?;
1624 self.declaration.push(elem);
1625 }
1626 _ => {
1627 self.__buffa_unknown_fields
1628 .push(::buffa::encoding::decode_unknown_field(tag, buf, depth)?);
1629 }
1630 }
1631 ::core::result::Result::Ok(())
1632 }
1633 fn cached_size(&self) -> u32 {
1634 self.__buffa_cached_size.get()
1635 }
1636 fn clear(&mut self) {
1637 self.features = ::buffa::MessageField::none();
1638 self.verification = ::core::option::Option::None;
1639 self.uninterpreted_option.clear();
1640 self.declaration.clear();
1641 self.__buffa_unknown_fields.clear();
1642 self.__buffa_cached_size.set(0);
1643 }
1644}
1645pub mod extension_range_options {
1646 #[allow(unused_imports)]
1647 use super::*;
1648 #[derive(Clone, Copy, PartialEq, Eq, Hash, Debug)]
1649 #[repr(i32)]
1650 pub enum VerificationState {
1651 DECLARATION = 0i32,
1652 UNVERIFIED = 1i32,
1653 }
1654 impl ::core::default::Default for VerificationState {
1655 fn default() -> Self {
1656 Self::DECLARATION
1657 }
1658 }
1659 impl ::buffa::Enumeration for VerificationState {
1660 fn from_i32(value: i32) -> ::core::option::Option<Self> {
1661 match value {
1662 0i32 => ::core::option::Option::Some(Self::DECLARATION),
1663 1i32 => ::core::option::Option::Some(Self::UNVERIFIED),
1664 _ => ::core::option::Option::None,
1665 }
1666 }
1667 fn to_i32(&self) -> i32 {
1668 *self as i32
1669 }
1670 fn proto_name(&self) -> &'static str {
1671 match self {
1672 Self::DECLARATION => "DECLARATION",
1673 Self::UNVERIFIED => "UNVERIFIED",
1674 }
1675 }
1676 fn from_proto_name(name: &str) -> ::core::option::Option<Self> {
1677 match name {
1678 "DECLARATION" => ::core::option::Option::Some(Self::DECLARATION),
1679 "UNVERIFIED" => ::core::option::Option::Some(Self::UNVERIFIED),
1680 _ => ::core::option::Option::None,
1681 }
1682 }
1683 }
1684 #[derive(Clone, PartialEq, Default)]
1685 pub struct Declaration {
1686 pub number: Option<i32>,
1688 pub full_name: Option<::buffa::alloc::string::String>,
1690 pub r#type: Option<::buffa::alloc::string::String>,
1692 pub reserved: Option<bool>,
1694 pub repeated: Option<bool>,
1696 #[doc(hidden)]
1697 pub __buffa_unknown_fields: ::buffa::UnknownFields,
1698 #[doc(hidden)]
1699 pub __buffa_cached_size: ::buffa::__private::CachedSize,
1700 }
1701 impl ::core::fmt::Debug for Declaration {
1702 fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
1703 f.debug_struct("Declaration")
1704 .field("number", &self.number)
1705 .field("full_name", &self.full_name)
1706 .field("r#type", &self.r#type)
1707 .field("reserved", &self.reserved)
1708 .field("repeated", &self.repeated)
1709 .finish()
1710 }
1711 }
1712 impl Declaration {
1713 pub const TYPE_URL: &'static str = "type.googleapis.com/google.protobuf.ExtensionRangeOptions.Declaration";
1718 }
1719 unsafe impl ::buffa::DefaultInstance for Declaration {
1720 fn default_instance() -> &'static Self {
1721 static VALUE: ::buffa::__private::OnceBox<Declaration> = ::buffa::__private::OnceBox::new();
1722 VALUE.get_or_init(|| ::buffa::alloc::boxed::Box::new(Declaration::default()))
1723 }
1724 }
1725 impl ::buffa::Message for Declaration {
1726 fn compute_size(&self) -> u32 {
1732 #[allow(unused_imports)]
1733 use ::buffa::Enumeration as _;
1734 let mut size = 0u32;
1735 if let Some(v) = self.number {
1736 size += 1u32 + ::buffa::types::int32_encoded_len(v) as u32;
1737 }
1738 if let Some(ref v) = self.full_name {
1739 size += 1u32 + ::buffa::types::string_encoded_len(v) as u32;
1740 }
1741 if let Some(ref v) = self.r#type {
1742 size += 1u32 + ::buffa::types::string_encoded_len(v) as u32;
1743 }
1744 if self.reserved.is_some() {
1745 size += 1u32 + ::buffa::types::BOOL_ENCODED_LEN as u32;
1746 }
1747 if self.repeated.is_some() {
1748 size += 1u32 + ::buffa::types::BOOL_ENCODED_LEN as u32;
1749 }
1750 size += self.__buffa_unknown_fields.encoded_len() as u32;
1751 self.__buffa_cached_size.set(size);
1752 size
1753 }
1754 fn write_to(&self, buf: &mut impl ::buffa::bytes::BufMut) {
1755 #[allow(unused_imports)]
1756 use ::buffa::Enumeration as _;
1757 if let Some(v) = self.number {
1758 ::buffa::encoding::Tag::new(1u32, ::buffa::encoding::WireType::Varint)
1759 .encode(buf);
1760 ::buffa::types::encode_int32(v, buf);
1761 }
1762 if let Some(ref v) = self.full_name {
1763 ::buffa::encoding::Tag::new(
1764 2u32,
1765 ::buffa::encoding::WireType::LengthDelimited,
1766 )
1767 .encode(buf);
1768 ::buffa::types::encode_string(v, buf);
1769 }
1770 if let Some(ref v) = self.r#type {
1771 ::buffa::encoding::Tag::new(
1772 3u32,
1773 ::buffa::encoding::WireType::LengthDelimited,
1774 )
1775 .encode(buf);
1776 ::buffa::types::encode_string(v, buf);
1777 }
1778 if let Some(v) = self.reserved {
1779 ::buffa::encoding::Tag::new(5u32, ::buffa::encoding::WireType::Varint)
1780 .encode(buf);
1781 ::buffa::types::encode_bool(v, buf);
1782 }
1783 if let Some(v) = self.repeated {
1784 ::buffa::encoding::Tag::new(6u32, ::buffa::encoding::WireType::Varint)
1785 .encode(buf);
1786 ::buffa::types::encode_bool(v, buf);
1787 }
1788 self.__buffa_unknown_fields.write_to(buf);
1789 }
1790 fn merge_field(
1791 &mut self,
1792 tag: ::buffa::encoding::Tag,
1793 buf: &mut impl ::buffa::bytes::Buf,
1794 depth: u32,
1795 ) -> ::core::result::Result<(), ::buffa::DecodeError> {
1796 #[allow(unused_imports)]
1797 use ::buffa::bytes::Buf as _;
1798 #[allow(unused_imports)]
1799 use ::buffa::Enumeration as _;
1800 match tag.field_number() {
1801 1u32 => {
1802 if tag.wire_type() != ::buffa::encoding::WireType::Varint {
1803 return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
1804 field_number: 1u32,
1805 expected: 0u8,
1806 actual: tag.wire_type() as u8,
1807 });
1808 }
1809 self.number = ::core::option::Option::Some(
1810 ::buffa::types::decode_int32(buf)?,
1811 );
1812 }
1813 2u32 => {
1814 if tag.wire_type() != ::buffa::encoding::WireType::LengthDelimited {
1815 return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
1816 field_number: 2u32,
1817 expected: 2u8,
1818 actual: tag.wire_type() as u8,
1819 });
1820 }
1821 ::buffa::types::merge_string(
1822 self
1823 .full_name
1824 .get_or_insert_with(::buffa::alloc::string::String::new),
1825 buf,
1826 )?;
1827 }
1828 3u32 => {
1829 if tag.wire_type() != ::buffa::encoding::WireType::LengthDelimited {
1830 return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
1831 field_number: 3u32,
1832 expected: 2u8,
1833 actual: tag.wire_type() as u8,
1834 });
1835 }
1836 ::buffa::types::merge_string(
1837 self
1838 .r#type
1839 .get_or_insert_with(::buffa::alloc::string::String::new),
1840 buf,
1841 )?;
1842 }
1843 5u32 => {
1844 if tag.wire_type() != ::buffa::encoding::WireType::Varint {
1845 return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
1846 field_number: 5u32,
1847 expected: 0u8,
1848 actual: tag.wire_type() as u8,
1849 });
1850 }
1851 self.reserved = ::core::option::Option::Some(
1852 ::buffa::types::decode_bool(buf)?,
1853 );
1854 }
1855 6u32 => {
1856 if tag.wire_type() != ::buffa::encoding::WireType::Varint {
1857 return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
1858 field_number: 6u32,
1859 expected: 0u8,
1860 actual: tag.wire_type() as u8,
1861 });
1862 }
1863 self.repeated = ::core::option::Option::Some(
1864 ::buffa::types::decode_bool(buf)?,
1865 );
1866 }
1867 _ => {
1868 self.__buffa_unknown_fields
1869 .push(::buffa::encoding::decode_unknown_field(tag, buf, depth)?);
1870 }
1871 }
1872 ::core::result::Result::Ok(())
1873 }
1874 fn cached_size(&self) -> u32 {
1875 self.__buffa_cached_size.get()
1876 }
1877 fn clear(&mut self) {
1878 self.number = ::core::option::Option::None;
1879 self.full_name = ::core::option::Option::None;
1880 self.r#type = ::core::option::Option::None;
1881 self.reserved = ::core::option::Option::None;
1882 self.repeated = ::core::option::Option::None;
1883 self.__buffa_unknown_fields.clear();
1884 self.__buffa_cached_size.set(0);
1885 }
1886 }
1887}
1888#[derive(Clone, PartialEq, Default)]
1889pub struct FieldDescriptorProto {
1890 pub name: Option<::buffa::alloc::string::String>,
1892 pub number: Option<i32>,
1894 pub label: Option<field_descriptor_proto::Label>,
1896 pub r#type: Option<field_descriptor_proto::Type>,
1898 pub type_name: Option<::buffa::alloc::string::String>,
1900 pub extendee: Option<::buffa::alloc::string::String>,
1902 pub default_value: Option<::buffa::alloc::string::String>,
1904 pub oneof_index: Option<i32>,
1906 pub json_name: Option<::buffa::alloc::string::String>,
1908 pub options: ::buffa::MessageField<FieldOptions>,
1910 pub proto3_optional: Option<bool>,
1912 #[doc(hidden)]
1913 pub __buffa_unknown_fields: ::buffa::UnknownFields,
1914 #[doc(hidden)]
1915 pub __buffa_cached_size: ::buffa::__private::CachedSize,
1916}
1917impl ::core::fmt::Debug for FieldDescriptorProto {
1918 fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
1919 f.debug_struct("FieldDescriptorProto")
1920 .field("name", &self.name)
1921 .field("number", &self.number)
1922 .field("label", &self.label)
1923 .field("r#type", &self.r#type)
1924 .field("type_name", &self.type_name)
1925 .field("extendee", &self.extendee)
1926 .field("default_value", &self.default_value)
1927 .field("oneof_index", &self.oneof_index)
1928 .field("json_name", &self.json_name)
1929 .field("options", &self.options)
1930 .field("proto3_optional", &self.proto3_optional)
1931 .finish()
1932 }
1933}
1934impl FieldDescriptorProto {
1935 pub const TYPE_URL: &'static str = "type.googleapis.com/google.protobuf.FieldDescriptorProto";
1940}
1941unsafe impl ::buffa::DefaultInstance for FieldDescriptorProto {
1942 fn default_instance() -> &'static Self {
1943 static VALUE: ::buffa::__private::OnceBox<FieldDescriptorProto> = ::buffa::__private::OnceBox::new();
1944 VALUE
1945 .get_or_init(|| ::buffa::alloc::boxed::Box::new(
1946 FieldDescriptorProto::default(),
1947 ))
1948 }
1949}
1950impl ::buffa::Message for FieldDescriptorProto {
1951 fn compute_size(&self) -> u32 {
1957 #[allow(unused_imports)]
1958 use ::buffa::Enumeration as _;
1959 let mut size = 0u32;
1960 if let Some(ref v) = self.name {
1961 size += 1u32 + ::buffa::types::string_encoded_len(v) as u32;
1962 }
1963 if let Some(v) = self.number {
1964 size += 1u32 + ::buffa::types::int32_encoded_len(v) as u32;
1965 }
1966 if let Some(ref v) = self.label {
1967 size += 1u32 + ::buffa::types::int32_encoded_len(v.to_i32()) as u32;
1968 }
1969 if let Some(ref v) = self.r#type {
1970 size += 1u32 + ::buffa::types::int32_encoded_len(v.to_i32()) as u32;
1971 }
1972 if let Some(ref v) = self.type_name {
1973 size += 1u32 + ::buffa::types::string_encoded_len(v) as u32;
1974 }
1975 if let Some(ref v) = self.extendee {
1976 size += 1u32 + ::buffa::types::string_encoded_len(v) as u32;
1977 }
1978 if let Some(ref v) = self.default_value {
1979 size += 1u32 + ::buffa::types::string_encoded_len(v) as u32;
1980 }
1981 if let Some(v) = self.oneof_index {
1982 size += 1u32 + ::buffa::types::int32_encoded_len(v) as u32;
1983 }
1984 if let Some(ref v) = self.json_name {
1985 size += 1u32 + ::buffa::types::string_encoded_len(v) as u32;
1986 }
1987 if self.options.is_set() {
1988 let inner_size = self.options.compute_size();
1989 size
1990 += 1u32 + ::buffa::encoding::varint_len(inner_size as u64) as u32
1991 + inner_size;
1992 }
1993 if self.proto3_optional.is_some() {
1994 size += 2u32 + ::buffa::types::BOOL_ENCODED_LEN as u32;
1995 }
1996 size += self.__buffa_unknown_fields.encoded_len() as u32;
1997 self.__buffa_cached_size.set(size);
1998 size
1999 }
2000 fn write_to(&self, buf: &mut impl ::buffa::bytes::BufMut) {
2001 #[allow(unused_imports)]
2002 use ::buffa::Enumeration as _;
2003 if let Some(ref v) = self.name {
2004 ::buffa::encoding::Tag::new(
2005 1u32,
2006 ::buffa::encoding::WireType::LengthDelimited,
2007 )
2008 .encode(buf);
2009 ::buffa::types::encode_string(v, buf);
2010 }
2011 if let Some(v) = self.number {
2012 ::buffa::encoding::Tag::new(3u32, ::buffa::encoding::WireType::Varint)
2013 .encode(buf);
2014 ::buffa::types::encode_int32(v, buf);
2015 }
2016 if let Some(ref v) = self.label {
2017 ::buffa::encoding::Tag::new(4u32, ::buffa::encoding::WireType::Varint)
2018 .encode(buf);
2019 ::buffa::types::encode_int32(v.to_i32(), buf);
2020 }
2021 if let Some(ref v) = self.r#type {
2022 ::buffa::encoding::Tag::new(5u32, ::buffa::encoding::WireType::Varint)
2023 .encode(buf);
2024 ::buffa::types::encode_int32(v.to_i32(), buf);
2025 }
2026 if let Some(ref v) = self.type_name {
2027 ::buffa::encoding::Tag::new(
2028 6u32,
2029 ::buffa::encoding::WireType::LengthDelimited,
2030 )
2031 .encode(buf);
2032 ::buffa::types::encode_string(v, buf);
2033 }
2034 if let Some(ref v) = self.extendee {
2035 ::buffa::encoding::Tag::new(
2036 2u32,
2037 ::buffa::encoding::WireType::LengthDelimited,
2038 )
2039 .encode(buf);
2040 ::buffa::types::encode_string(v, buf);
2041 }
2042 if let Some(ref v) = self.default_value {
2043 ::buffa::encoding::Tag::new(
2044 7u32,
2045 ::buffa::encoding::WireType::LengthDelimited,
2046 )
2047 .encode(buf);
2048 ::buffa::types::encode_string(v, buf);
2049 }
2050 if let Some(v) = self.oneof_index {
2051 ::buffa::encoding::Tag::new(9u32, ::buffa::encoding::WireType::Varint)
2052 .encode(buf);
2053 ::buffa::types::encode_int32(v, buf);
2054 }
2055 if let Some(ref v) = self.json_name {
2056 ::buffa::encoding::Tag::new(
2057 10u32,
2058 ::buffa::encoding::WireType::LengthDelimited,
2059 )
2060 .encode(buf);
2061 ::buffa::types::encode_string(v, buf);
2062 }
2063 if self.options.is_set() {
2064 ::buffa::encoding::Tag::new(
2065 8u32,
2066 ::buffa::encoding::WireType::LengthDelimited,
2067 )
2068 .encode(buf);
2069 ::buffa::encoding::encode_varint(self.options.cached_size() as u64, buf);
2070 self.options.write_to(buf);
2071 }
2072 if let Some(v) = self.proto3_optional {
2073 ::buffa::encoding::Tag::new(17u32, ::buffa::encoding::WireType::Varint)
2074 .encode(buf);
2075 ::buffa::types::encode_bool(v, buf);
2076 }
2077 self.__buffa_unknown_fields.write_to(buf);
2078 }
2079 fn merge_field(
2080 &mut self,
2081 tag: ::buffa::encoding::Tag,
2082 buf: &mut impl ::buffa::bytes::Buf,
2083 depth: u32,
2084 ) -> ::core::result::Result<(), ::buffa::DecodeError> {
2085 #[allow(unused_imports)]
2086 use ::buffa::bytes::Buf as _;
2087 #[allow(unused_imports)]
2088 use ::buffa::Enumeration as _;
2089 match tag.field_number() {
2090 1u32 => {
2091 if tag.wire_type() != ::buffa::encoding::WireType::LengthDelimited {
2092 return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
2093 field_number: 1u32,
2094 expected: 2u8,
2095 actual: tag.wire_type() as u8,
2096 });
2097 }
2098 ::buffa::types::merge_string(
2099 self.name.get_or_insert_with(::buffa::alloc::string::String::new),
2100 buf,
2101 )?;
2102 }
2103 3u32 => {
2104 if tag.wire_type() != ::buffa::encoding::WireType::Varint {
2105 return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
2106 field_number: 3u32,
2107 expected: 0u8,
2108 actual: tag.wire_type() as u8,
2109 });
2110 }
2111 self.number = ::core::option::Option::Some(
2112 ::buffa::types::decode_int32(buf)?,
2113 );
2114 }
2115 4u32 => {
2116 if tag.wire_type() != ::buffa::encoding::WireType::Varint {
2117 return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
2118 field_number: 4u32,
2119 expected: 0u8,
2120 actual: tag.wire_type() as u8,
2121 });
2122 }
2123 let __raw = ::buffa::types::decode_int32(buf)?;
2124 if let ::core::option::Option::Some(__v) = ::buffa::Enumeration::from_i32(
2125 __raw,
2126 ) {
2127 self.label = ::core::option::Option::Some(__v);
2128 } else {
2129 self.__buffa_unknown_fields
2130 .push(::buffa::UnknownField {
2131 number: 4u32,
2132 data: ::buffa::UnknownFieldData::Varint(__raw as u64),
2133 });
2134 }
2135 }
2136 5u32 => {
2137 if tag.wire_type() != ::buffa::encoding::WireType::Varint {
2138 return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
2139 field_number: 5u32,
2140 expected: 0u8,
2141 actual: tag.wire_type() as u8,
2142 });
2143 }
2144 let __raw = ::buffa::types::decode_int32(buf)?;
2145 if let ::core::option::Option::Some(__v) = ::buffa::Enumeration::from_i32(
2146 __raw,
2147 ) {
2148 self.r#type = ::core::option::Option::Some(__v);
2149 } else {
2150 self.__buffa_unknown_fields
2151 .push(::buffa::UnknownField {
2152 number: 5u32,
2153 data: ::buffa::UnknownFieldData::Varint(__raw as u64),
2154 });
2155 }
2156 }
2157 6u32 => {
2158 if tag.wire_type() != ::buffa::encoding::WireType::LengthDelimited {
2159 return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
2160 field_number: 6u32,
2161 expected: 2u8,
2162 actual: tag.wire_type() as u8,
2163 });
2164 }
2165 ::buffa::types::merge_string(
2166 self
2167 .type_name
2168 .get_or_insert_with(::buffa::alloc::string::String::new),
2169 buf,
2170 )?;
2171 }
2172 2u32 => {
2173 if tag.wire_type() != ::buffa::encoding::WireType::LengthDelimited {
2174 return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
2175 field_number: 2u32,
2176 expected: 2u8,
2177 actual: tag.wire_type() as u8,
2178 });
2179 }
2180 ::buffa::types::merge_string(
2181 self
2182 .extendee
2183 .get_or_insert_with(::buffa::alloc::string::String::new),
2184 buf,
2185 )?;
2186 }
2187 7u32 => {
2188 if tag.wire_type() != ::buffa::encoding::WireType::LengthDelimited {
2189 return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
2190 field_number: 7u32,
2191 expected: 2u8,
2192 actual: tag.wire_type() as u8,
2193 });
2194 }
2195 ::buffa::types::merge_string(
2196 self
2197 .default_value
2198 .get_or_insert_with(::buffa::alloc::string::String::new),
2199 buf,
2200 )?;
2201 }
2202 9u32 => {
2203 if tag.wire_type() != ::buffa::encoding::WireType::Varint {
2204 return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
2205 field_number: 9u32,
2206 expected: 0u8,
2207 actual: tag.wire_type() as u8,
2208 });
2209 }
2210 self.oneof_index = ::core::option::Option::Some(
2211 ::buffa::types::decode_int32(buf)?,
2212 );
2213 }
2214 10u32 => {
2215 if tag.wire_type() != ::buffa::encoding::WireType::LengthDelimited {
2216 return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
2217 field_number: 10u32,
2218 expected: 2u8,
2219 actual: tag.wire_type() as u8,
2220 });
2221 }
2222 ::buffa::types::merge_string(
2223 self
2224 .json_name
2225 .get_or_insert_with(::buffa::alloc::string::String::new),
2226 buf,
2227 )?;
2228 }
2229 8u32 => {
2230 if tag.wire_type() != ::buffa::encoding::WireType::LengthDelimited {
2231 return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
2232 field_number: 8u32,
2233 expected: 2u8,
2234 actual: tag.wire_type() as u8,
2235 });
2236 }
2237 ::buffa::Message::merge_length_delimited(
2238 self.options.get_or_insert_default(),
2239 buf,
2240 depth,
2241 )?;
2242 }
2243 17u32 => {
2244 if tag.wire_type() != ::buffa::encoding::WireType::Varint {
2245 return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
2246 field_number: 17u32,
2247 expected: 0u8,
2248 actual: tag.wire_type() as u8,
2249 });
2250 }
2251 self.proto3_optional = ::core::option::Option::Some(
2252 ::buffa::types::decode_bool(buf)?,
2253 );
2254 }
2255 _ => {
2256 self.__buffa_unknown_fields
2257 .push(::buffa::encoding::decode_unknown_field(tag, buf, depth)?);
2258 }
2259 }
2260 ::core::result::Result::Ok(())
2261 }
2262 fn cached_size(&self) -> u32 {
2263 self.__buffa_cached_size.get()
2264 }
2265 fn clear(&mut self) {
2266 self.name = ::core::option::Option::None;
2267 self.number = ::core::option::Option::None;
2268 self.label = ::core::option::Option::None;
2269 self.r#type = ::core::option::Option::None;
2270 self.type_name = ::core::option::Option::None;
2271 self.extendee = ::core::option::Option::None;
2272 self.default_value = ::core::option::Option::None;
2273 self.oneof_index = ::core::option::Option::None;
2274 self.json_name = ::core::option::Option::None;
2275 self.options = ::buffa::MessageField::none();
2276 self.proto3_optional = ::core::option::Option::None;
2277 self.__buffa_unknown_fields.clear();
2278 self.__buffa_cached_size.set(0);
2279 }
2280}
2281pub mod field_descriptor_proto {
2282 #[allow(unused_imports)]
2283 use super::*;
2284 #[derive(Clone, Copy, PartialEq, Eq, Hash, Debug)]
2285 #[repr(i32)]
2286 pub enum Type {
2287 TYPE_DOUBLE = 1i32,
2288 TYPE_FLOAT = 2i32,
2289 TYPE_INT64 = 3i32,
2290 TYPE_UINT64 = 4i32,
2291 TYPE_INT32 = 5i32,
2292 TYPE_FIXED64 = 6i32,
2293 TYPE_FIXED32 = 7i32,
2294 TYPE_BOOL = 8i32,
2295 TYPE_STRING = 9i32,
2296 TYPE_GROUP = 10i32,
2297 TYPE_MESSAGE = 11i32,
2298 TYPE_BYTES = 12i32,
2299 TYPE_UINT32 = 13i32,
2300 TYPE_ENUM = 14i32,
2301 TYPE_SFIXED32 = 15i32,
2302 TYPE_SFIXED64 = 16i32,
2303 TYPE_SINT32 = 17i32,
2304 TYPE_SINT64 = 18i32,
2305 }
2306 impl ::core::default::Default for Type {
2307 fn default() -> Self {
2308 Self::TYPE_DOUBLE
2309 }
2310 }
2311 impl ::buffa::Enumeration for Type {
2312 fn from_i32(value: i32) -> ::core::option::Option<Self> {
2313 match value {
2314 1i32 => ::core::option::Option::Some(Self::TYPE_DOUBLE),
2315 2i32 => ::core::option::Option::Some(Self::TYPE_FLOAT),
2316 3i32 => ::core::option::Option::Some(Self::TYPE_INT64),
2317 4i32 => ::core::option::Option::Some(Self::TYPE_UINT64),
2318 5i32 => ::core::option::Option::Some(Self::TYPE_INT32),
2319 6i32 => ::core::option::Option::Some(Self::TYPE_FIXED64),
2320 7i32 => ::core::option::Option::Some(Self::TYPE_FIXED32),
2321 8i32 => ::core::option::Option::Some(Self::TYPE_BOOL),
2322 9i32 => ::core::option::Option::Some(Self::TYPE_STRING),
2323 10i32 => ::core::option::Option::Some(Self::TYPE_GROUP),
2324 11i32 => ::core::option::Option::Some(Self::TYPE_MESSAGE),
2325 12i32 => ::core::option::Option::Some(Self::TYPE_BYTES),
2326 13i32 => ::core::option::Option::Some(Self::TYPE_UINT32),
2327 14i32 => ::core::option::Option::Some(Self::TYPE_ENUM),
2328 15i32 => ::core::option::Option::Some(Self::TYPE_SFIXED32),
2329 16i32 => ::core::option::Option::Some(Self::TYPE_SFIXED64),
2330 17i32 => ::core::option::Option::Some(Self::TYPE_SINT32),
2331 18i32 => ::core::option::Option::Some(Self::TYPE_SINT64),
2332 _ => ::core::option::Option::None,
2333 }
2334 }
2335 fn to_i32(&self) -> i32 {
2336 *self as i32
2337 }
2338 fn proto_name(&self) -> &'static str {
2339 match self {
2340 Self::TYPE_DOUBLE => "TYPE_DOUBLE",
2341 Self::TYPE_FLOAT => "TYPE_FLOAT",
2342 Self::TYPE_INT64 => "TYPE_INT64",
2343 Self::TYPE_UINT64 => "TYPE_UINT64",
2344 Self::TYPE_INT32 => "TYPE_INT32",
2345 Self::TYPE_FIXED64 => "TYPE_FIXED64",
2346 Self::TYPE_FIXED32 => "TYPE_FIXED32",
2347 Self::TYPE_BOOL => "TYPE_BOOL",
2348 Self::TYPE_STRING => "TYPE_STRING",
2349 Self::TYPE_GROUP => "TYPE_GROUP",
2350 Self::TYPE_MESSAGE => "TYPE_MESSAGE",
2351 Self::TYPE_BYTES => "TYPE_BYTES",
2352 Self::TYPE_UINT32 => "TYPE_UINT32",
2353 Self::TYPE_ENUM => "TYPE_ENUM",
2354 Self::TYPE_SFIXED32 => "TYPE_SFIXED32",
2355 Self::TYPE_SFIXED64 => "TYPE_SFIXED64",
2356 Self::TYPE_SINT32 => "TYPE_SINT32",
2357 Self::TYPE_SINT64 => "TYPE_SINT64",
2358 }
2359 }
2360 fn from_proto_name(name: &str) -> ::core::option::Option<Self> {
2361 match name {
2362 "TYPE_DOUBLE" => ::core::option::Option::Some(Self::TYPE_DOUBLE),
2363 "TYPE_FLOAT" => ::core::option::Option::Some(Self::TYPE_FLOAT),
2364 "TYPE_INT64" => ::core::option::Option::Some(Self::TYPE_INT64),
2365 "TYPE_UINT64" => ::core::option::Option::Some(Self::TYPE_UINT64),
2366 "TYPE_INT32" => ::core::option::Option::Some(Self::TYPE_INT32),
2367 "TYPE_FIXED64" => ::core::option::Option::Some(Self::TYPE_FIXED64),
2368 "TYPE_FIXED32" => ::core::option::Option::Some(Self::TYPE_FIXED32),
2369 "TYPE_BOOL" => ::core::option::Option::Some(Self::TYPE_BOOL),
2370 "TYPE_STRING" => ::core::option::Option::Some(Self::TYPE_STRING),
2371 "TYPE_GROUP" => ::core::option::Option::Some(Self::TYPE_GROUP),
2372 "TYPE_MESSAGE" => ::core::option::Option::Some(Self::TYPE_MESSAGE),
2373 "TYPE_BYTES" => ::core::option::Option::Some(Self::TYPE_BYTES),
2374 "TYPE_UINT32" => ::core::option::Option::Some(Self::TYPE_UINT32),
2375 "TYPE_ENUM" => ::core::option::Option::Some(Self::TYPE_ENUM),
2376 "TYPE_SFIXED32" => ::core::option::Option::Some(Self::TYPE_SFIXED32),
2377 "TYPE_SFIXED64" => ::core::option::Option::Some(Self::TYPE_SFIXED64),
2378 "TYPE_SINT32" => ::core::option::Option::Some(Self::TYPE_SINT32),
2379 "TYPE_SINT64" => ::core::option::Option::Some(Self::TYPE_SINT64),
2380 _ => ::core::option::Option::None,
2381 }
2382 }
2383 }
2384 #[derive(Clone, Copy, PartialEq, Eq, Hash, Debug)]
2385 #[repr(i32)]
2386 pub enum Label {
2387 LABEL_OPTIONAL = 1i32,
2388 LABEL_REPEATED = 3i32,
2389 LABEL_REQUIRED = 2i32,
2390 }
2391 impl ::core::default::Default for Label {
2392 fn default() -> Self {
2393 Self::LABEL_OPTIONAL
2394 }
2395 }
2396 impl ::buffa::Enumeration for Label {
2397 fn from_i32(value: i32) -> ::core::option::Option<Self> {
2398 match value {
2399 1i32 => ::core::option::Option::Some(Self::LABEL_OPTIONAL),
2400 3i32 => ::core::option::Option::Some(Self::LABEL_REPEATED),
2401 2i32 => ::core::option::Option::Some(Self::LABEL_REQUIRED),
2402 _ => ::core::option::Option::None,
2403 }
2404 }
2405 fn to_i32(&self) -> i32 {
2406 *self as i32
2407 }
2408 fn proto_name(&self) -> &'static str {
2409 match self {
2410 Self::LABEL_OPTIONAL => "LABEL_OPTIONAL",
2411 Self::LABEL_REPEATED => "LABEL_REPEATED",
2412 Self::LABEL_REQUIRED => "LABEL_REQUIRED",
2413 }
2414 }
2415 fn from_proto_name(name: &str) -> ::core::option::Option<Self> {
2416 match name {
2417 "LABEL_OPTIONAL" => ::core::option::Option::Some(Self::LABEL_OPTIONAL),
2418 "LABEL_REPEATED" => ::core::option::Option::Some(Self::LABEL_REPEATED),
2419 "LABEL_REQUIRED" => ::core::option::Option::Some(Self::LABEL_REQUIRED),
2420 _ => ::core::option::Option::None,
2421 }
2422 }
2423 }
2424}
2425#[derive(Clone, PartialEq, Default)]
2426pub struct OneofDescriptorProto {
2427 pub name: Option<::buffa::alloc::string::String>,
2429 pub options: ::buffa::MessageField<OneofOptions>,
2431 #[doc(hidden)]
2432 pub __buffa_unknown_fields: ::buffa::UnknownFields,
2433 #[doc(hidden)]
2434 pub __buffa_cached_size: ::buffa::__private::CachedSize,
2435}
2436impl ::core::fmt::Debug for OneofDescriptorProto {
2437 fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
2438 f.debug_struct("OneofDescriptorProto")
2439 .field("name", &self.name)
2440 .field("options", &self.options)
2441 .finish()
2442 }
2443}
2444impl OneofDescriptorProto {
2445 pub const TYPE_URL: &'static str = "type.googleapis.com/google.protobuf.OneofDescriptorProto";
2450}
2451unsafe impl ::buffa::DefaultInstance for OneofDescriptorProto {
2452 fn default_instance() -> &'static Self {
2453 static VALUE: ::buffa::__private::OnceBox<OneofDescriptorProto> = ::buffa::__private::OnceBox::new();
2454 VALUE
2455 .get_or_init(|| ::buffa::alloc::boxed::Box::new(
2456 OneofDescriptorProto::default(),
2457 ))
2458 }
2459}
2460impl ::buffa::Message for OneofDescriptorProto {
2461 fn compute_size(&self) -> u32 {
2467 #[allow(unused_imports)]
2468 use ::buffa::Enumeration as _;
2469 let mut size = 0u32;
2470 if let Some(ref v) = self.name {
2471 size += 1u32 + ::buffa::types::string_encoded_len(v) as u32;
2472 }
2473 if self.options.is_set() {
2474 let inner_size = self.options.compute_size();
2475 size
2476 += 1u32 + ::buffa::encoding::varint_len(inner_size as u64) as u32
2477 + inner_size;
2478 }
2479 size += self.__buffa_unknown_fields.encoded_len() as u32;
2480 self.__buffa_cached_size.set(size);
2481 size
2482 }
2483 fn write_to(&self, buf: &mut impl ::buffa::bytes::BufMut) {
2484 #[allow(unused_imports)]
2485 use ::buffa::Enumeration as _;
2486 if let Some(ref v) = self.name {
2487 ::buffa::encoding::Tag::new(
2488 1u32,
2489 ::buffa::encoding::WireType::LengthDelimited,
2490 )
2491 .encode(buf);
2492 ::buffa::types::encode_string(v, buf);
2493 }
2494 if self.options.is_set() {
2495 ::buffa::encoding::Tag::new(
2496 2u32,
2497 ::buffa::encoding::WireType::LengthDelimited,
2498 )
2499 .encode(buf);
2500 ::buffa::encoding::encode_varint(self.options.cached_size() as u64, buf);
2501 self.options.write_to(buf);
2502 }
2503 self.__buffa_unknown_fields.write_to(buf);
2504 }
2505 fn merge_field(
2506 &mut self,
2507 tag: ::buffa::encoding::Tag,
2508 buf: &mut impl ::buffa::bytes::Buf,
2509 depth: u32,
2510 ) -> ::core::result::Result<(), ::buffa::DecodeError> {
2511 #[allow(unused_imports)]
2512 use ::buffa::bytes::Buf as _;
2513 #[allow(unused_imports)]
2514 use ::buffa::Enumeration as _;
2515 match tag.field_number() {
2516 1u32 => {
2517 if tag.wire_type() != ::buffa::encoding::WireType::LengthDelimited {
2518 return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
2519 field_number: 1u32,
2520 expected: 2u8,
2521 actual: tag.wire_type() as u8,
2522 });
2523 }
2524 ::buffa::types::merge_string(
2525 self.name.get_or_insert_with(::buffa::alloc::string::String::new),
2526 buf,
2527 )?;
2528 }
2529 2u32 => {
2530 if tag.wire_type() != ::buffa::encoding::WireType::LengthDelimited {
2531 return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
2532 field_number: 2u32,
2533 expected: 2u8,
2534 actual: tag.wire_type() as u8,
2535 });
2536 }
2537 ::buffa::Message::merge_length_delimited(
2538 self.options.get_or_insert_default(),
2539 buf,
2540 depth,
2541 )?;
2542 }
2543 _ => {
2544 self.__buffa_unknown_fields
2545 .push(::buffa::encoding::decode_unknown_field(tag, buf, depth)?);
2546 }
2547 }
2548 ::core::result::Result::Ok(())
2549 }
2550 fn cached_size(&self) -> u32 {
2551 self.__buffa_cached_size.get()
2552 }
2553 fn clear(&mut self) {
2554 self.name = ::core::option::Option::None;
2555 self.options = ::buffa::MessageField::none();
2556 self.__buffa_unknown_fields.clear();
2557 self.__buffa_cached_size.set(0);
2558 }
2559}
2560#[derive(Clone, PartialEq, Default)]
2561pub struct EnumDescriptorProto {
2562 pub name: Option<::buffa::alloc::string::String>,
2564 pub value: ::buffa::alloc::vec::Vec<EnumValueDescriptorProto>,
2566 pub options: ::buffa::MessageField<EnumOptions>,
2568 pub reserved_range: ::buffa::alloc::vec::Vec<
2570 enum_descriptor_proto::EnumReservedRange,
2571 >,
2572 pub reserved_name: ::buffa::alloc::vec::Vec<::buffa::alloc::string::String>,
2574 pub visibility: Option<SymbolVisibility>,
2576 #[doc(hidden)]
2577 pub __buffa_unknown_fields: ::buffa::UnknownFields,
2578 #[doc(hidden)]
2579 pub __buffa_cached_size: ::buffa::__private::CachedSize,
2580}
2581impl ::core::fmt::Debug for EnumDescriptorProto {
2582 fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
2583 f.debug_struct("EnumDescriptorProto")
2584 .field("name", &self.name)
2585 .field("value", &self.value)
2586 .field("options", &self.options)
2587 .field("reserved_range", &self.reserved_range)
2588 .field("reserved_name", &self.reserved_name)
2589 .field("visibility", &self.visibility)
2590 .finish()
2591 }
2592}
2593impl EnumDescriptorProto {
2594 pub const TYPE_URL: &'static str = "type.googleapis.com/google.protobuf.EnumDescriptorProto";
2599}
2600unsafe impl ::buffa::DefaultInstance for EnumDescriptorProto {
2601 fn default_instance() -> &'static Self {
2602 static VALUE: ::buffa::__private::OnceBox<EnumDescriptorProto> = ::buffa::__private::OnceBox::new();
2603 VALUE
2604 .get_or_init(|| ::buffa::alloc::boxed::Box::new(
2605 EnumDescriptorProto::default(),
2606 ))
2607 }
2608}
2609impl ::buffa::Message for EnumDescriptorProto {
2610 fn compute_size(&self) -> u32 {
2616 #[allow(unused_imports)]
2617 use ::buffa::Enumeration as _;
2618 let mut size = 0u32;
2619 if let Some(ref v) = self.name {
2620 size += 1u32 + ::buffa::types::string_encoded_len(v) as u32;
2621 }
2622 if self.options.is_set() {
2623 let inner_size = self.options.compute_size();
2624 size
2625 += 1u32 + ::buffa::encoding::varint_len(inner_size as u64) as u32
2626 + inner_size;
2627 }
2628 if let Some(ref v) = self.visibility {
2629 size += 1u32 + ::buffa::types::int32_encoded_len(v.to_i32()) as u32;
2630 }
2631 for v in &self.value {
2632 let inner_size = v.compute_size();
2633 size
2634 += 1u32 + ::buffa::encoding::varint_len(inner_size as u64) as u32
2635 + inner_size;
2636 }
2637 for v in &self.reserved_range {
2638 let inner_size = v.compute_size();
2639 size
2640 += 1u32 + ::buffa::encoding::varint_len(inner_size as u64) as u32
2641 + inner_size;
2642 }
2643 for v in &self.reserved_name {
2644 size += 1u32 + ::buffa::types::string_encoded_len(v) as u32;
2645 }
2646 size += self.__buffa_unknown_fields.encoded_len() as u32;
2647 self.__buffa_cached_size.set(size);
2648 size
2649 }
2650 fn write_to(&self, buf: &mut impl ::buffa::bytes::BufMut) {
2651 #[allow(unused_imports)]
2652 use ::buffa::Enumeration as _;
2653 if let Some(ref v) = self.name {
2654 ::buffa::encoding::Tag::new(
2655 1u32,
2656 ::buffa::encoding::WireType::LengthDelimited,
2657 )
2658 .encode(buf);
2659 ::buffa::types::encode_string(v, buf);
2660 }
2661 if self.options.is_set() {
2662 ::buffa::encoding::Tag::new(
2663 3u32,
2664 ::buffa::encoding::WireType::LengthDelimited,
2665 )
2666 .encode(buf);
2667 ::buffa::encoding::encode_varint(self.options.cached_size() as u64, buf);
2668 self.options.write_to(buf);
2669 }
2670 if let Some(ref v) = self.visibility {
2671 ::buffa::encoding::Tag::new(6u32, ::buffa::encoding::WireType::Varint)
2672 .encode(buf);
2673 ::buffa::types::encode_int32(v.to_i32(), buf);
2674 }
2675 for v in &self.value {
2676 ::buffa::encoding::Tag::new(
2677 2u32,
2678 ::buffa::encoding::WireType::LengthDelimited,
2679 )
2680 .encode(buf);
2681 ::buffa::encoding::encode_varint(v.cached_size() as u64, buf);
2682 v.write_to(buf);
2683 }
2684 for v in &self.reserved_range {
2685 ::buffa::encoding::Tag::new(
2686 4u32,
2687 ::buffa::encoding::WireType::LengthDelimited,
2688 )
2689 .encode(buf);
2690 ::buffa::encoding::encode_varint(v.cached_size() as u64, buf);
2691 v.write_to(buf);
2692 }
2693 for v in &self.reserved_name {
2694 ::buffa::encoding::Tag::new(
2695 5u32,
2696 ::buffa::encoding::WireType::LengthDelimited,
2697 )
2698 .encode(buf);
2699 ::buffa::types::encode_string(v, buf);
2700 }
2701 self.__buffa_unknown_fields.write_to(buf);
2702 }
2703 fn merge_field(
2704 &mut self,
2705 tag: ::buffa::encoding::Tag,
2706 buf: &mut impl ::buffa::bytes::Buf,
2707 depth: u32,
2708 ) -> ::core::result::Result<(), ::buffa::DecodeError> {
2709 #[allow(unused_imports)]
2710 use ::buffa::bytes::Buf as _;
2711 #[allow(unused_imports)]
2712 use ::buffa::Enumeration as _;
2713 match tag.field_number() {
2714 1u32 => {
2715 if tag.wire_type() != ::buffa::encoding::WireType::LengthDelimited {
2716 return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
2717 field_number: 1u32,
2718 expected: 2u8,
2719 actual: tag.wire_type() as u8,
2720 });
2721 }
2722 ::buffa::types::merge_string(
2723 self.name.get_or_insert_with(::buffa::alloc::string::String::new),
2724 buf,
2725 )?;
2726 }
2727 3u32 => {
2728 if tag.wire_type() != ::buffa::encoding::WireType::LengthDelimited {
2729 return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
2730 field_number: 3u32,
2731 expected: 2u8,
2732 actual: tag.wire_type() as u8,
2733 });
2734 }
2735 ::buffa::Message::merge_length_delimited(
2736 self.options.get_or_insert_default(),
2737 buf,
2738 depth,
2739 )?;
2740 }
2741 6u32 => {
2742 if tag.wire_type() != ::buffa::encoding::WireType::Varint {
2743 return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
2744 field_number: 6u32,
2745 expected: 0u8,
2746 actual: tag.wire_type() as u8,
2747 });
2748 }
2749 let __raw = ::buffa::types::decode_int32(buf)?;
2750 if let ::core::option::Option::Some(__v) = ::buffa::Enumeration::from_i32(
2751 __raw,
2752 ) {
2753 self.visibility = ::core::option::Option::Some(__v);
2754 } else {
2755 self.__buffa_unknown_fields
2756 .push(::buffa::UnknownField {
2757 number: 6u32,
2758 data: ::buffa::UnknownFieldData::Varint(__raw as u64),
2759 });
2760 }
2761 }
2762 2u32 => {
2763 if tag.wire_type() != ::buffa::encoding::WireType::LengthDelimited {
2764 return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
2765 field_number: 2u32,
2766 expected: 2u8,
2767 actual: tag.wire_type() as u8,
2768 });
2769 }
2770 let mut elem = ::core::default::Default::default();
2771 ::buffa::Message::merge_length_delimited(&mut elem, buf, depth)?;
2772 self.value.push(elem);
2773 }
2774 4u32 => {
2775 if tag.wire_type() != ::buffa::encoding::WireType::LengthDelimited {
2776 return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
2777 field_number: 4u32,
2778 expected: 2u8,
2779 actual: tag.wire_type() as u8,
2780 });
2781 }
2782 let mut elem = ::core::default::Default::default();
2783 ::buffa::Message::merge_length_delimited(&mut elem, buf, depth)?;
2784 self.reserved_range.push(elem);
2785 }
2786 5u32 => {
2787 if tag.wire_type() != ::buffa::encoding::WireType::LengthDelimited {
2788 return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
2789 field_number: 5u32,
2790 expected: 2u8,
2791 actual: tag.wire_type() as u8,
2792 });
2793 }
2794 self.reserved_name.push(::buffa::types::decode_string(buf)?);
2795 }
2796 _ => {
2797 self.__buffa_unknown_fields
2798 .push(::buffa::encoding::decode_unknown_field(tag, buf, depth)?);
2799 }
2800 }
2801 ::core::result::Result::Ok(())
2802 }
2803 fn cached_size(&self) -> u32 {
2804 self.__buffa_cached_size.get()
2805 }
2806 fn clear(&mut self) {
2807 self.name = ::core::option::Option::None;
2808 self.options = ::buffa::MessageField::none();
2809 self.visibility = ::core::option::Option::None;
2810 self.value.clear();
2811 self.reserved_range.clear();
2812 self.reserved_name.clear();
2813 self.__buffa_unknown_fields.clear();
2814 self.__buffa_cached_size.set(0);
2815 }
2816}
2817pub mod enum_descriptor_proto {
2818 #[allow(unused_imports)]
2819 use super::*;
2820 #[derive(Clone, PartialEq, Default)]
2821 pub struct EnumReservedRange {
2822 pub start: Option<i32>,
2824 pub end: Option<i32>,
2826 #[doc(hidden)]
2827 pub __buffa_unknown_fields: ::buffa::UnknownFields,
2828 #[doc(hidden)]
2829 pub __buffa_cached_size: ::buffa::__private::CachedSize,
2830 }
2831 impl ::core::fmt::Debug for EnumReservedRange {
2832 fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
2833 f.debug_struct("EnumReservedRange")
2834 .field("start", &self.start)
2835 .field("end", &self.end)
2836 .finish()
2837 }
2838 }
2839 impl EnumReservedRange {
2840 pub const TYPE_URL: &'static str = "type.googleapis.com/google.protobuf.EnumDescriptorProto.EnumReservedRange";
2845 }
2846 unsafe impl ::buffa::DefaultInstance for EnumReservedRange {
2847 fn default_instance() -> &'static Self {
2848 static VALUE: ::buffa::__private::OnceBox<EnumReservedRange> = ::buffa::__private::OnceBox::new();
2849 VALUE
2850 .get_or_init(|| ::buffa::alloc::boxed::Box::new(
2851 EnumReservedRange::default(),
2852 ))
2853 }
2854 }
2855 impl ::buffa::Message for EnumReservedRange {
2856 fn compute_size(&self) -> u32 {
2862 #[allow(unused_imports)]
2863 use ::buffa::Enumeration as _;
2864 let mut size = 0u32;
2865 if let Some(v) = self.start {
2866 size += 1u32 + ::buffa::types::int32_encoded_len(v) as u32;
2867 }
2868 if let Some(v) = self.end {
2869 size += 1u32 + ::buffa::types::int32_encoded_len(v) as u32;
2870 }
2871 size += self.__buffa_unknown_fields.encoded_len() as u32;
2872 self.__buffa_cached_size.set(size);
2873 size
2874 }
2875 fn write_to(&self, buf: &mut impl ::buffa::bytes::BufMut) {
2876 #[allow(unused_imports)]
2877 use ::buffa::Enumeration as _;
2878 if let Some(v) = self.start {
2879 ::buffa::encoding::Tag::new(1u32, ::buffa::encoding::WireType::Varint)
2880 .encode(buf);
2881 ::buffa::types::encode_int32(v, buf);
2882 }
2883 if let Some(v) = self.end {
2884 ::buffa::encoding::Tag::new(2u32, ::buffa::encoding::WireType::Varint)
2885 .encode(buf);
2886 ::buffa::types::encode_int32(v, buf);
2887 }
2888 self.__buffa_unknown_fields.write_to(buf);
2889 }
2890 fn merge_field(
2891 &mut self,
2892 tag: ::buffa::encoding::Tag,
2893 buf: &mut impl ::buffa::bytes::Buf,
2894 depth: u32,
2895 ) -> ::core::result::Result<(), ::buffa::DecodeError> {
2896 #[allow(unused_imports)]
2897 use ::buffa::bytes::Buf as _;
2898 #[allow(unused_imports)]
2899 use ::buffa::Enumeration as _;
2900 match tag.field_number() {
2901 1u32 => {
2902 if tag.wire_type() != ::buffa::encoding::WireType::Varint {
2903 return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
2904 field_number: 1u32,
2905 expected: 0u8,
2906 actual: tag.wire_type() as u8,
2907 });
2908 }
2909 self.start = ::core::option::Option::Some(
2910 ::buffa::types::decode_int32(buf)?,
2911 );
2912 }
2913 2u32 => {
2914 if tag.wire_type() != ::buffa::encoding::WireType::Varint {
2915 return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
2916 field_number: 2u32,
2917 expected: 0u8,
2918 actual: tag.wire_type() as u8,
2919 });
2920 }
2921 self.end = ::core::option::Option::Some(
2922 ::buffa::types::decode_int32(buf)?,
2923 );
2924 }
2925 _ => {
2926 self.__buffa_unknown_fields
2927 .push(::buffa::encoding::decode_unknown_field(tag, buf, depth)?);
2928 }
2929 }
2930 ::core::result::Result::Ok(())
2931 }
2932 fn cached_size(&self) -> u32 {
2933 self.__buffa_cached_size.get()
2934 }
2935 fn clear(&mut self) {
2936 self.start = ::core::option::Option::None;
2937 self.end = ::core::option::Option::None;
2938 self.__buffa_unknown_fields.clear();
2939 self.__buffa_cached_size.set(0);
2940 }
2941 }
2942}
2943#[derive(Clone, PartialEq, Default)]
2944pub struct EnumValueDescriptorProto {
2945 pub name: Option<::buffa::alloc::string::String>,
2947 pub number: Option<i32>,
2949 pub options: ::buffa::MessageField<EnumValueOptions>,
2951 #[doc(hidden)]
2952 pub __buffa_unknown_fields: ::buffa::UnknownFields,
2953 #[doc(hidden)]
2954 pub __buffa_cached_size: ::buffa::__private::CachedSize,
2955}
2956impl ::core::fmt::Debug for EnumValueDescriptorProto {
2957 fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
2958 f.debug_struct("EnumValueDescriptorProto")
2959 .field("name", &self.name)
2960 .field("number", &self.number)
2961 .field("options", &self.options)
2962 .finish()
2963 }
2964}
2965impl EnumValueDescriptorProto {
2966 pub const TYPE_URL: &'static str = "type.googleapis.com/google.protobuf.EnumValueDescriptorProto";
2971}
2972unsafe impl ::buffa::DefaultInstance for EnumValueDescriptorProto {
2973 fn default_instance() -> &'static Self {
2974 static VALUE: ::buffa::__private::OnceBox<EnumValueDescriptorProto> = ::buffa::__private::OnceBox::new();
2975 VALUE
2976 .get_or_init(|| ::buffa::alloc::boxed::Box::new(
2977 EnumValueDescriptorProto::default(),
2978 ))
2979 }
2980}
2981impl ::buffa::Message for EnumValueDescriptorProto {
2982 fn compute_size(&self) -> u32 {
2988 #[allow(unused_imports)]
2989 use ::buffa::Enumeration as _;
2990 let mut size = 0u32;
2991 if let Some(ref v) = self.name {
2992 size += 1u32 + ::buffa::types::string_encoded_len(v) as u32;
2993 }
2994 if let Some(v) = self.number {
2995 size += 1u32 + ::buffa::types::int32_encoded_len(v) as u32;
2996 }
2997 if self.options.is_set() {
2998 let inner_size = self.options.compute_size();
2999 size
3000 += 1u32 + ::buffa::encoding::varint_len(inner_size as u64) as u32
3001 + inner_size;
3002 }
3003 size += self.__buffa_unknown_fields.encoded_len() as u32;
3004 self.__buffa_cached_size.set(size);
3005 size
3006 }
3007 fn write_to(&self, buf: &mut impl ::buffa::bytes::BufMut) {
3008 #[allow(unused_imports)]
3009 use ::buffa::Enumeration as _;
3010 if let Some(ref v) = self.name {
3011 ::buffa::encoding::Tag::new(
3012 1u32,
3013 ::buffa::encoding::WireType::LengthDelimited,
3014 )
3015 .encode(buf);
3016 ::buffa::types::encode_string(v, buf);
3017 }
3018 if let Some(v) = self.number {
3019 ::buffa::encoding::Tag::new(2u32, ::buffa::encoding::WireType::Varint)
3020 .encode(buf);
3021 ::buffa::types::encode_int32(v, buf);
3022 }
3023 if self.options.is_set() {
3024 ::buffa::encoding::Tag::new(
3025 3u32,
3026 ::buffa::encoding::WireType::LengthDelimited,
3027 )
3028 .encode(buf);
3029 ::buffa::encoding::encode_varint(self.options.cached_size() as u64, buf);
3030 self.options.write_to(buf);
3031 }
3032 self.__buffa_unknown_fields.write_to(buf);
3033 }
3034 fn merge_field(
3035 &mut self,
3036 tag: ::buffa::encoding::Tag,
3037 buf: &mut impl ::buffa::bytes::Buf,
3038 depth: u32,
3039 ) -> ::core::result::Result<(), ::buffa::DecodeError> {
3040 #[allow(unused_imports)]
3041 use ::buffa::bytes::Buf as _;
3042 #[allow(unused_imports)]
3043 use ::buffa::Enumeration as _;
3044 match tag.field_number() {
3045 1u32 => {
3046 if tag.wire_type() != ::buffa::encoding::WireType::LengthDelimited {
3047 return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
3048 field_number: 1u32,
3049 expected: 2u8,
3050 actual: tag.wire_type() as u8,
3051 });
3052 }
3053 ::buffa::types::merge_string(
3054 self.name.get_or_insert_with(::buffa::alloc::string::String::new),
3055 buf,
3056 )?;
3057 }
3058 2u32 => {
3059 if tag.wire_type() != ::buffa::encoding::WireType::Varint {
3060 return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
3061 field_number: 2u32,
3062 expected: 0u8,
3063 actual: tag.wire_type() as u8,
3064 });
3065 }
3066 self.number = ::core::option::Option::Some(
3067 ::buffa::types::decode_int32(buf)?,
3068 );
3069 }
3070 3u32 => {
3071 if tag.wire_type() != ::buffa::encoding::WireType::LengthDelimited {
3072 return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
3073 field_number: 3u32,
3074 expected: 2u8,
3075 actual: tag.wire_type() as u8,
3076 });
3077 }
3078 ::buffa::Message::merge_length_delimited(
3079 self.options.get_or_insert_default(),
3080 buf,
3081 depth,
3082 )?;
3083 }
3084 _ => {
3085 self.__buffa_unknown_fields
3086 .push(::buffa::encoding::decode_unknown_field(tag, buf, depth)?);
3087 }
3088 }
3089 ::core::result::Result::Ok(())
3090 }
3091 fn cached_size(&self) -> u32 {
3092 self.__buffa_cached_size.get()
3093 }
3094 fn clear(&mut self) {
3095 self.name = ::core::option::Option::None;
3096 self.number = ::core::option::Option::None;
3097 self.options = ::buffa::MessageField::none();
3098 self.__buffa_unknown_fields.clear();
3099 self.__buffa_cached_size.set(0);
3100 }
3101}
3102#[derive(Clone, PartialEq, Default)]
3103pub struct ServiceDescriptorProto {
3104 pub name: Option<::buffa::alloc::string::String>,
3106 pub method: ::buffa::alloc::vec::Vec<MethodDescriptorProto>,
3108 pub options: ::buffa::MessageField<ServiceOptions>,
3110 #[doc(hidden)]
3111 pub __buffa_unknown_fields: ::buffa::UnknownFields,
3112 #[doc(hidden)]
3113 pub __buffa_cached_size: ::buffa::__private::CachedSize,
3114}
3115impl ::core::fmt::Debug for ServiceDescriptorProto {
3116 fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
3117 f.debug_struct("ServiceDescriptorProto")
3118 .field("name", &self.name)
3119 .field("method", &self.method)
3120 .field("options", &self.options)
3121 .finish()
3122 }
3123}
3124impl ServiceDescriptorProto {
3125 pub const TYPE_URL: &'static str = "type.googleapis.com/google.protobuf.ServiceDescriptorProto";
3130}
3131unsafe impl ::buffa::DefaultInstance for ServiceDescriptorProto {
3132 fn default_instance() -> &'static Self {
3133 static VALUE: ::buffa::__private::OnceBox<ServiceDescriptorProto> = ::buffa::__private::OnceBox::new();
3134 VALUE
3135 .get_or_init(|| ::buffa::alloc::boxed::Box::new(
3136 ServiceDescriptorProto::default(),
3137 ))
3138 }
3139}
3140impl ::buffa::Message for ServiceDescriptorProto {
3141 fn compute_size(&self) -> u32 {
3147 #[allow(unused_imports)]
3148 use ::buffa::Enumeration as _;
3149 let mut size = 0u32;
3150 if let Some(ref v) = self.name {
3151 size += 1u32 + ::buffa::types::string_encoded_len(v) as u32;
3152 }
3153 if self.options.is_set() {
3154 let inner_size = self.options.compute_size();
3155 size
3156 += 1u32 + ::buffa::encoding::varint_len(inner_size as u64) as u32
3157 + inner_size;
3158 }
3159 for v in &self.method {
3160 let inner_size = v.compute_size();
3161 size
3162 += 1u32 + ::buffa::encoding::varint_len(inner_size as u64) as u32
3163 + inner_size;
3164 }
3165 size += self.__buffa_unknown_fields.encoded_len() as u32;
3166 self.__buffa_cached_size.set(size);
3167 size
3168 }
3169 fn write_to(&self, buf: &mut impl ::buffa::bytes::BufMut) {
3170 #[allow(unused_imports)]
3171 use ::buffa::Enumeration as _;
3172 if let Some(ref v) = self.name {
3173 ::buffa::encoding::Tag::new(
3174 1u32,
3175 ::buffa::encoding::WireType::LengthDelimited,
3176 )
3177 .encode(buf);
3178 ::buffa::types::encode_string(v, buf);
3179 }
3180 if self.options.is_set() {
3181 ::buffa::encoding::Tag::new(
3182 3u32,
3183 ::buffa::encoding::WireType::LengthDelimited,
3184 )
3185 .encode(buf);
3186 ::buffa::encoding::encode_varint(self.options.cached_size() as u64, buf);
3187 self.options.write_to(buf);
3188 }
3189 for v in &self.method {
3190 ::buffa::encoding::Tag::new(
3191 2u32,
3192 ::buffa::encoding::WireType::LengthDelimited,
3193 )
3194 .encode(buf);
3195 ::buffa::encoding::encode_varint(v.cached_size() as u64, buf);
3196 v.write_to(buf);
3197 }
3198 self.__buffa_unknown_fields.write_to(buf);
3199 }
3200 fn merge_field(
3201 &mut self,
3202 tag: ::buffa::encoding::Tag,
3203 buf: &mut impl ::buffa::bytes::Buf,
3204 depth: u32,
3205 ) -> ::core::result::Result<(), ::buffa::DecodeError> {
3206 #[allow(unused_imports)]
3207 use ::buffa::bytes::Buf as _;
3208 #[allow(unused_imports)]
3209 use ::buffa::Enumeration as _;
3210 match tag.field_number() {
3211 1u32 => {
3212 if tag.wire_type() != ::buffa::encoding::WireType::LengthDelimited {
3213 return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
3214 field_number: 1u32,
3215 expected: 2u8,
3216 actual: tag.wire_type() as u8,
3217 });
3218 }
3219 ::buffa::types::merge_string(
3220 self.name.get_or_insert_with(::buffa::alloc::string::String::new),
3221 buf,
3222 )?;
3223 }
3224 3u32 => {
3225 if tag.wire_type() != ::buffa::encoding::WireType::LengthDelimited {
3226 return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
3227 field_number: 3u32,
3228 expected: 2u8,
3229 actual: tag.wire_type() as u8,
3230 });
3231 }
3232 ::buffa::Message::merge_length_delimited(
3233 self.options.get_or_insert_default(),
3234 buf,
3235 depth,
3236 )?;
3237 }
3238 2u32 => {
3239 if tag.wire_type() != ::buffa::encoding::WireType::LengthDelimited {
3240 return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
3241 field_number: 2u32,
3242 expected: 2u8,
3243 actual: tag.wire_type() as u8,
3244 });
3245 }
3246 let mut elem = ::core::default::Default::default();
3247 ::buffa::Message::merge_length_delimited(&mut elem, buf, depth)?;
3248 self.method.push(elem);
3249 }
3250 _ => {
3251 self.__buffa_unknown_fields
3252 .push(::buffa::encoding::decode_unknown_field(tag, buf, depth)?);
3253 }
3254 }
3255 ::core::result::Result::Ok(())
3256 }
3257 fn cached_size(&self) -> u32 {
3258 self.__buffa_cached_size.get()
3259 }
3260 fn clear(&mut self) {
3261 self.name = ::core::option::Option::None;
3262 self.options = ::buffa::MessageField::none();
3263 self.method.clear();
3264 self.__buffa_unknown_fields.clear();
3265 self.__buffa_cached_size.set(0);
3266 }
3267}
3268#[derive(Clone, PartialEq, Default)]
3269pub struct MethodDescriptorProto {
3270 pub name: Option<::buffa::alloc::string::String>,
3272 pub input_type: Option<::buffa::alloc::string::String>,
3274 pub output_type: Option<::buffa::alloc::string::String>,
3276 pub options: ::buffa::MessageField<MethodOptions>,
3278 pub client_streaming: Option<bool>,
3280 pub server_streaming: Option<bool>,
3282 #[doc(hidden)]
3283 pub __buffa_unknown_fields: ::buffa::UnknownFields,
3284 #[doc(hidden)]
3285 pub __buffa_cached_size: ::buffa::__private::CachedSize,
3286}
3287impl ::core::fmt::Debug for MethodDescriptorProto {
3288 fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
3289 f.debug_struct("MethodDescriptorProto")
3290 .field("name", &self.name)
3291 .field("input_type", &self.input_type)
3292 .field("output_type", &self.output_type)
3293 .field("options", &self.options)
3294 .field("client_streaming", &self.client_streaming)
3295 .field("server_streaming", &self.server_streaming)
3296 .finish()
3297 }
3298}
3299impl MethodDescriptorProto {
3300 pub const TYPE_URL: &'static str = "type.googleapis.com/google.protobuf.MethodDescriptorProto";
3305}
3306unsafe impl ::buffa::DefaultInstance for MethodDescriptorProto {
3307 fn default_instance() -> &'static Self {
3308 static VALUE: ::buffa::__private::OnceBox<MethodDescriptorProto> = ::buffa::__private::OnceBox::new();
3309 VALUE
3310 .get_or_init(|| ::buffa::alloc::boxed::Box::new(
3311 MethodDescriptorProto::default(),
3312 ))
3313 }
3314}
3315impl ::buffa::Message for MethodDescriptorProto {
3316 fn compute_size(&self) -> u32 {
3322 #[allow(unused_imports)]
3323 use ::buffa::Enumeration as _;
3324 let mut size = 0u32;
3325 if let Some(ref v) = self.name {
3326 size += 1u32 + ::buffa::types::string_encoded_len(v) as u32;
3327 }
3328 if let Some(ref v) = self.input_type {
3329 size += 1u32 + ::buffa::types::string_encoded_len(v) as u32;
3330 }
3331 if let Some(ref v) = self.output_type {
3332 size += 1u32 + ::buffa::types::string_encoded_len(v) as u32;
3333 }
3334 if self.options.is_set() {
3335 let inner_size = self.options.compute_size();
3336 size
3337 += 1u32 + ::buffa::encoding::varint_len(inner_size as u64) as u32
3338 + inner_size;
3339 }
3340 if self.client_streaming.is_some() {
3341 size += 1u32 + ::buffa::types::BOOL_ENCODED_LEN as u32;
3342 }
3343 if self.server_streaming.is_some() {
3344 size += 1u32 + ::buffa::types::BOOL_ENCODED_LEN as u32;
3345 }
3346 size += self.__buffa_unknown_fields.encoded_len() as u32;
3347 self.__buffa_cached_size.set(size);
3348 size
3349 }
3350 fn write_to(&self, buf: &mut impl ::buffa::bytes::BufMut) {
3351 #[allow(unused_imports)]
3352 use ::buffa::Enumeration as _;
3353 if let Some(ref v) = self.name {
3354 ::buffa::encoding::Tag::new(
3355 1u32,
3356 ::buffa::encoding::WireType::LengthDelimited,
3357 )
3358 .encode(buf);
3359 ::buffa::types::encode_string(v, buf);
3360 }
3361 if let Some(ref v) = self.input_type {
3362 ::buffa::encoding::Tag::new(
3363 2u32,
3364 ::buffa::encoding::WireType::LengthDelimited,
3365 )
3366 .encode(buf);
3367 ::buffa::types::encode_string(v, buf);
3368 }
3369 if let Some(ref v) = self.output_type {
3370 ::buffa::encoding::Tag::new(
3371 3u32,
3372 ::buffa::encoding::WireType::LengthDelimited,
3373 )
3374 .encode(buf);
3375 ::buffa::types::encode_string(v, buf);
3376 }
3377 if self.options.is_set() {
3378 ::buffa::encoding::Tag::new(
3379 4u32,
3380 ::buffa::encoding::WireType::LengthDelimited,
3381 )
3382 .encode(buf);
3383 ::buffa::encoding::encode_varint(self.options.cached_size() as u64, buf);
3384 self.options.write_to(buf);
3385 }
3386 if let Some(v) = self.client_streaming {
3387 ::buffa::encoding::Tag::new(5u32, ::buffa::encoding::WireType::Varint)
3388 .encode(buf);
3389 ::buffa::types::encode_bool(v, buf);
3390 }
3391 if let Some(v) = self.server_streaming {
3392 ::buffa::encoding::Tag::new(6u32, ::buffa::encoding::WireType::Varint)
3393 .encode(buf);
3394 ::buffa::types::encode_bool(v, buf);
3395 }
3396 self.__buffa_unknown_fields.write_to(buf);
3397 }
3398 fn merge_field(
3399 &mut self,
3400 tag: ::buffa::encoding::Tag,
3401 buf: &mut impl ::buffa::bytes::Buf,
3402 depth: u32,
3403 ) -> ::core::result::Result<(), ::buffa::DecodeError> {
3404 #[allow(unused_imports)]
3405 use ::buffa::bytes::Buf as _;
3406 #[allow(unused_imports)]
3407 use ::buffa::Enumeration as _;
3408 match tag.field_number() {
3409 1u32 => {
3410 if tag.wire_type() != ::buffa::encoding::WireType::LengthDelimited {
3411 return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
3412 field_number: 1u32,
3413 expected: 2u8,
3414 actual: tag.wire_type() as u8,
3415 });
3416 }
3417 ::buffa::types::merge_string(
3418 self.name.get_or_insert_with(::buffa::alloc::string::String::new),
3419 buf,
3420 )?;
3421 }
3422 2u32 => {
3423 if tag.wire_type() != ::buffa::encoding::WireType::LengthDelimited {
3424 return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
3425 field_number: 2u32,
3426 expected: 2u8,
3427 actual: tag.wire_type() as u8,
3428 });
3429 }
3430 ::buffa::types::merge_string(
3431 self
3432 .input_type
3433 .get_or_insert_with(::buffa::alloc::string::String::new),
3434 buf,
3435 )?;
3436 }
3437 3u32 => {
3438 if tag.wire_type() != ::buffa::encoding::WireType::LengthDelimited {
3439 return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
3440 field_number: 3u32,
3441 expected: 2u8,
3442 actual: tag.wire_type() as u8,
3443 });
3444 }
3445 ::buffa::types::merge_string(
3446 self
3447 .output_type
3448 .get_or_insert_with(::buffa::alloc::string::String::new),
3449 buf,
3450 )?;
3451 }
3452 4u32 => {
3453 if tag.wire_type() != ::buffa::encoding::WireType::LengthDelimited {
3454 return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
3455 field_number: 4u32,
3456 expected: 2u8,
3457 actual: tag.wire_type() as u8,
3458 });
3459 }
3460 ::buffa::Message::merge_length_delimited(
3461 self.options.get_or_insert_default(),
3462 buf,
3463 depth,
3464 )?;
3465 }
3466 5u32 => {
3467 if tag.wire_type() != ::buffa::encoding::WireType::Varint {
3468 return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
3469 field_number: 5u32,
3470 expected: 0u8,
3471 actual: tag.wire_type() as u8,
3472 });
3473 }
3474 self.client_streaming = ::core::option::Option::Some(
3475 ::buffa::types::decode_bool(buf)?,
3476 );
3477 }
3478 6u32 => {
3479 if tag.wire_type() != ::buffa::encoding::WireType::Varint {
3480 return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
3481 field_number: 6u32,
3482 expected: 0u8,
3483 actual: tag.wire_type() as u8,
3484 });
3485 }
3486 self.server_streaming = ::core::option::Option::Some(
3487 ::buffa::types::decode_bool(buf)?,
3488 );
3489 }
3490 _ => {
3491 self.__buffa_unknown_fields
3492 .push(::buffa::encoding::decode_unknown_field(tag, buf, depth)?);
3493 }
3494 }
3495 ::core::result::Result::Ok(())
3496 }
3497 fn cached_size(&self) -> u32 {
3498 self.__buffa_cached_size.get()
3499 }
3500 fn clear(&mut self) {
3501 self.name = ::core::option::Option::None;
3502 self.input_type = ::core::option::Option::None;
3503 self.output_type = ::core::option::Option::None;
3504 self.options = ::buffa::MessageField::none();
3505 self.client_streaming = ::core::option::Option::None;
3506 self.server_streaming = ::core::option::Option::None;
3507 self.__buffa_unknown_fields.clear();
3508 self.__buffa_cached_size.set(0);
3509 }
3510}
3511#[derive(Clone, PartialEq, Default)]
3512pub struct FileOptions {
3513 pub java_package: Option<::buffa::alloc::string::String>,
3515 pub java_outer_classname: Option<::buffa::alloc::string::String>,
3517 pub java_multiple_files: Option<bool>,
3519 pub java_generate_equals_and_hash: Option<bool>,
3521 pub java_string_check_utf8: Option<bool>,
3523 pub optimize_for: Option<file_options::OptimizeMode>,
3525 pub go_package: Option<::buffa::alloc::string::String>,
3527 pub cc_generic_services: Option<bool>,
3529 pub java_generic_services: Option<bool>,
3531 pub py_generic_services: Option<bool>,
3533 pub deprecated: Option<bool>,
3535 pub cc_enable_arenas: Option<bool>,
3537 pub objc_class_prefix: Option<::buffa::alloc::string::String>,
3539 pub csharp_namespace: Option<::buffa::alloc::string::String>,
3541 pub swift_prefix: Option<::buffa::alloc::string::String>,
3543 pub php_class_prefix: Option<::buffa::alloc::string::String>,
3545 pub php_namespace: Option<::buffa::alloc::string::String>,
3547 pub php_metadata_namespace: Option<::buffa::alloc::string::String>,
3549 pub ruby_package: Option<::buffa::alloc::string::String>,
3551 pub features: ::buffa::MessageField<FeatureSet>,
3553 pub uninterpreted_option: ::buffa::alloc::vec::Vec<UninterpretedOption>,
3555 #[doc(hidden)]
3556 pub __buffa_unknown_fields: ::buffa::UnknownFields,
3557 #[doc(hidden)]
3558 pub __buffa_cached_size: ::buffa::__private::CachedSize,
3559}
3560impl ::core::fmt::Debug for FileOptions {
3561 fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
3562 f.debug_struct("FileOptions")
3563 .field("java_package", &self.java_package)
3564 .field("java_outer_classname", &self.java_outer_classname)
3565 .field("java_multiple_files", &self.java_multiple_files)
3566 .field("java_generate_equals_and_hash", &self.java_generate_equals_and_hash)
3567 .field("java_string_check_utf8", &self.java_string_check_utf8)
3568 .field("optimize_for", &self.optimize_for)
3569 .field("go_package", &self.go_package)
3570 .field("cc_generic_services", &self.cc_generic_services)
3571 .field("java_generic_services", &self.java_generic_services)
3572 .field("py_generic_services", &self.py_generic_services)
3573 .field("deprecated", &self.deprecated)
3574 .field("cc_enable_arenas", &self.cc_enable_arenas)
3575 .field("objc_class_prefix", &self.objc_class_prefix)
3576 .field("csharp_namespace", &self.csharp_namespace)
3577 .field("swift_prefix", &self.swift_prefix)
3578 .field("php_class_prefix", &self.php_class_prefix)
3579 .field("php_namespace", &self.php_namespace)
3580 .field("php_metadata_namespace", &self.php_metadata_namespace)
3581 .field("ruby_package", &self.ruby_package)
3582 .field("features", &self.features)
3583 .field("uninterpreted_option", &self.uninterpreted_option)
3584 .finish()
3585 }
3586}
3587impl FileOptions {
3588 pub const TYPE_URL: &'static str = "type.googleapis.com/google.protobuf.FileOptions";
3593}
3594unsafe impl ::buffa::DefaultInstance for FileOptions {
3595 fn default_instance() -> &'static Self {
3596 static VALUE: ::buffa::__private::OnceBox<FileOptions> = ::buffa::__private::OnceBox::new();
3597 VALUE.get_or_init(|| ::buffa::alloc::boxed::Box::new(FileOptions::default()))
3598 }
3599}
3600impl ::buffa::Message for FileOptions {
3601 fn compute_size(&self) -> u32 {
3607 #[allow(unused_imports)]
3608 use ::buffa::Enumeration as _;
3609 let mut size = 0u32;
3610 if let Some(ref v) = self.java_package {
3611 size += 1u32 + ::buffa::types::string_encoded_len(v) as u32;
3612 }
3613 if let Some(ref v) = self.java_outer_classname {
3614 size += 1u32 + ::buffa::types::string_encoded_len(v) as u32;
3615 }
3616 if self.java_multiple_files.is_some() {
3617 size += 1u32 + ::buffa::types::BOOL_ENCODED_LEN as u32;
3618 }
3619 if self.java_generate_equals_and_hash.is_some() {
3620 size += 2u32 + ::buffa::types::BOOL_ENCODED_LEN as u32;
3621 }
3622 if self.java_string_check_utf8.is_some() {
3623 size += 2u32 + ::buffa::types::BOOL_ENCODED_LEN as u32;
3624 }
3625 if let Some(ref v) = self.optimize_for {
3626 size += 1u32 + ::buffa::types::int32_encoded_len(v.to_i32()) as u32;
3627 }
3628 if let Some(ref v) = self.go_package {
3629 size += 1u32 + ::buffa::types::string_encoded_len(v) as u32;
3630 }
3631 if self.cc_generic_services.is_some() {
3632 size += 2u32 + ::buffa::types::BOOL_ENCODED_LEN as u32;
3633 }
3634 if self.java_generic_services.is_some() {
3635 size += 2u32 + ::buffa::types::BOOL_ENCODED_LEN as u32;
3636 }
3637 if self.py_generic_services.is_some() {
3638 size += 2u32 + ::buffa::types::BOOL_ENCODED_LEN as u32;
3639 }
3640 if self.deprecated.is_some() {
3641 size += 2u32 + ::buffa::types::BOOL_ENCODED_LEN as u32;
3642 }
3643 if self.cc_enable_arenas.is_some() {
3644 size += 2u32 + ::buffa::types::BOOL_ENCODED_LEN as u32;
3645 }
3646 if let Some(ref v) = self.objc_class_prefix {
3647 size += 2u32 + ::buffa::types::string_encoded_len(v) as u32;
3648 }
3649 if let Some(ref v) = self.csharp_namespace {
3650 size += 2u32 + ::buffa::types::string_encoded_len(v) as u32;
3651 }
3652 if let Some(ref v) = self.swift_prefix {
3653 size += 2u32 + ::buffa::types::string_encoded_len(v) as u32;
3654 }
3655 if let Some(ref v) = self.php_class_prefix {
3656 size += 2u32 + ::buffa::types::string_encoded_len(v) as u32;
3657 }
3658 if let Some(ref v) = self.php_namespace {
3659 size += 2u32 + ::buffa::types::string_encoded_len(v) as u32;
3660 }
3661 if let Some(ref v) = self.php_metadata_namespace {
3662 size += 2u32 + ::buffa::types::string_encoded_len(v) as u32;
3663 }
3664 if let Some(ref v) = self.ruby_package {
3665 size += 2u32 + ::buffa::types::string_encoded_len(v) as u32;
3666 }
3667 if self.features.is_set() {
3668 let inner_size = self.features.compute_size();
3669 size
3670 += 2u32 + ::buffa::encoding::varint_len(inner_size as u64) as u32
3671 + inner_size;
3672 }
3673 for v in &self.uninterpreted_option {
3674 let inner_size = v.compute_size();
3675 size
3676 += 2u32 + ::buffa::encoding::varint_len(inner_size as u64) as u32
3677 + inner_size;
3678 }
3679 size += self.__buffa_unknown_fields.encoded_len() as u32;
3680 self.__buffa_cached_size.set(size);
3681 size
3682 }
3683 fn write_to(&self, buf: &mut impl ::buffa::bytes::BufMut) {
3684 #[allow(unused_imports)]
3685 use ::buffa::Enumeration as _;
3686 if let Some(ref v) = self.java_package {
3687 ::buffa::encoding::Tag::new(
3688 1u32,
3689 ::buffa::encoding::WireType::LengthDelimited,
3690 )
3691 .encode(buf);
3692 ::buffa::types::encode_string(v, buf);
3693 }
3694 if let Some(ref v) = self.java_outer_classname {
3695 ::buffa::encoding::Tag::new(
3696 8u32,
3697 ::buffa::encoding::WireType::LengthDelimited,
3698 )
3699 .encode(buf);
3700 ::buffa::types::encode_string(v, buf);
3701 }
3702 if let Some(v) = self.java_multiple_files {
3703 ::buffa::encoding::Tag::new(10u32, ::buffa::encoding::WireType::Varint)
3704 .encode(buf);
3705 ::buffa::types::encode_bool(v, buf);
3706 }
3707 if let Some(v) = self.java_generate_equals_and_hash {
3708 ::buffa::encoding::Tag::new(20u32, ::buffa::encoding::WireType::Varint)
3709 .encode(buf);
3710 ::buffa::types::encode_bool(v, buf);
3711 }
3712 if let Some(v) = self.java_string_check_utf8 {
3713 ::buffa::encoding::Tag::new(27u32, ::buffa::encoding::WireType::Varint)
3714 .encode(buf);
3715 ::buffa::types::encode_bool(v, buf);
3716 }
3717 if let Some(ref v) = self.optimize_for {
3718 ::buffa::encoding::Tag::new(9u32, ::buffa::encoding::WireType::Varint)
3719 .encode(buf);
3720 ::buffa::types::encode_int32(v.to_i32(), buf);
3721 }
3722 if let Some(ref v) = self.go_package {
3723 ::buffa::encoding::Tag::new(
3724 11u32,
3725 ::buffa::encoding::WireType::LengthDelimited,
3726 )
3727 .encode(buf);
3728 ::buffa::types::encode_string(v, buf);
3729 }
3730 if let Some(v) = self.cc_generic_services {
3731 ::buffa::encoding::Tag::new(16u32, ::buffa::encoding::WireType::Varint)
3732 .encode(buf);
3733 ::buffa::types::encode_bool(v, buf);
3734 }
3735 if let Some(v) = self.java_generic_services {
3736 ::buffa::encoding::Tag::new(17u32, ::buffa::encoding::WireType::Varint)
3737 .encode(buf);
3738 ::buffa::types::encode_bool(v, buf);
3739 }
3740 if let Some(v) = self.py_generic_services {
3741 ::buffa::encoding::Tag::new(18u32, ::buffa::encoding::WireType::Varint)
3742 .encode(buf);
3743 ::buffa::types::encode_bool(v, buf);
3744 }
3745 if let Some(v) = self.deprecated {
3746 ::buffa::encoding::Tag::new(23u32, ::buffa::encoding::WireType::Varint)
3747 .encode(buf);
3748 ::buffa::types::encode_bool(v, buf);
3749 }
3750 if let Some(v) = self.cc_enable_arenas {
3751 ::buffa::encoding::Tag::new(31u32, ::buffa::encoding::WireType::Varint)
3752 .encode(buf);
3753 ::buffa::types::encode_bool(v, buf);
3754 }
3755 if let Some(ref v) = self.objc_class_prefix {
3756 ::buffa::encoding::Tag::new(
3757 36u32,
3758 ::buffa::encoding::WireType::LengthDelimited,
3759 )
3760 .encode(buf);
3761 ::buffa::types::encode_string(v, buf);
3762 }
3763 if let Some(ref v) = self.csharp_namespace {
3764 ::buffa::encoding::Tag::new(
3765 37u32,
3766 ::buffa::encoding::WireType::LengthDelimited,
3767 )
3768 .encode(buf);
3769 ::buffa::types::encode_string(v, buf);
3770 }
3771 if let Some(ref v) = self.swift_prefix {
3772 ::buffa::encoding::Tag::new(
3773 39u32,
3774 ::buffa::encoding::WireType::LengthDelimited,
3775 )
3776 .encode(buf);
3777 ::buffa::types::encode_string(v, buf);
3778 }
3779 if let Some(ref v) = self.php_class_prefix {
3780 ::buffa::encoding::Tag::new(
3781 40u32,
3782 ::buffa::encoding::WireType::LengthDelimited,
3783 )
3784 .encode(buf);
3785 ::buffa::types::encode_string(v, buf);
3786 }
3787 if let Some(ref v) = self.php_namespace {
3788 ::buffa::encoding::Tag::new(
3789 41u32,
3790 ::buffa::encoding::WireType::LengthDelimited,
3791 )
3792 .encode(buf);
3793 ::buffa::types::encode_string(v, buf);
3794 }
3795 if let Some(ref v) = self.php_metadata_namespace {
3796 ::buffa::encoding::Tag::new(
3797 44u32,
3798 ::buffa::encoding::WireType::LengthDelimited,
3799 )
3800 .encode(buf);
3801 ::buffa::types::encode_string(v, buf);
3802 }
3803 if let Some(ref v) = self.ruby_package {
3804 ::buffa::encoding::Tag::new(
3805 45u32,
3806 ::buffa::encoding::WireType::LengthDelimited,
3807 )
3808 .encode(buf);
3809 ::buffa::types::encode_string(v, buf);
3810 }
3811 if self.features.is_set() {
3812 ::buffa::encoding::Tag::new(
3813 50u32,
3814 ::buffa::encoding::WireType::LengthDelimited,
3815 )
3816 .encode(buf);
3817 ::buffa::encoding::encode_varint(self.features.cached_size() as u64, buf);
3818 self.features.write_to(buf);
3819 }
3820 for v in &self.uninterpreted_option {
3821 ::buffa::encoding::Tag::new(
3822 999u32,
3823 ::buffa::encoding::WireType::LengthDelimited,
3824 )
3825 .encode(buf);
3826 ::buffa::encoding::encode_varint(v.cached_size() as u64, buf);
3827 v.write_to(buf);
3828 }
3829 self.__buffa_unknown_fields.write_to(buf);
3830 }
3831 fn merge_field(
3832 &mut self,
3833 tag: ::buffa::encoding::Tag,
3834 buf: &mut impl ::buffa::bytes::Buf,
3835 depth: u32,
3836 ) -> ::core::result::Result<(), ::buffa::DecodeError> {
3837 #[allow(unused_imports)]
3838 use ::buffa::bytes::Buf as _;
3839 #[allow(unused_imports)]
3840 use ::buffa::Enumeration as _;
3841 match tag.field_number() {
3842 1u32 => {
3843 if tag.wire_type() != ::buffa::encoding::WireType::LengthDelimited {
3844 return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
3845 field_number: 1u32,
3846 expected: 2u8,
3847 actual: tag.wire_type() as u8,
3848 });
3849 }
3850 ::buffa::types::merge_string(
3851 self
3852 .java_package
3853 .get_or_insert_with(::buffa::alloc::string::String::new),
3854 buf,
3855 )?;
3856 }
3857 8u32 => {
3858 if tag.wire_type() != ::buffa::encoding::WireType::LengthDelimited {
3859 return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
3860 field_number: 8u32,
3861 expected: 2u8,
3862 actual: tag.wire_type() as u8,
3863 });
3864 }
3865 ::buffa::types::merge_string(
3866 self
3867 .java_outer_classname
3868 .get_or_insert_with(::buffa::alloc::string::String::new),
3869 buf,
3870 )?;
3871 }
3872 10u32 => {
3873 if tag.wire_type() != ::buffa::encoding::WireType::Varint {
3874 return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
3875 field_number: 10u32,
3876 expected: 0u8,
3877 actual: tag.wire_type() as u8,
3878 });
3879 }
3880 self.java_multiple_files = ::core::option::Option::Some(
3881 ::buffa::types::decode_bool(buf)?,
3882 );
3883 }
3884 20u32 => {
3885 if tag.wire_type() != ::buffa::encoding::WireType::Varint {
3886 return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
3887 field_number: 20u32,
3888 expected: 0u8,
3889 actual: tag.wire_type() as u8,
3890 });
3891 }
3892 self.java_generate_equals_and_hash = ::core::option::Option::Some(
3893 ::buffa::types::decode_bool(buf)?,
3894 );
3895 }
3896 27u32 => {
3897 if tag.wire_type() != ::buffa::encoding::WireType::Varint {
3898 return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
3899 field_number: 27u32,
3900 expected: 0u8,
3901 actual: tag.wire_type() as u8,
3902 });
3903 }
3904 self.java_string_check_utf8 = ::core::option::Option::Some(
3905 ::buffa::types::decode_bool(buf)?,
3906 );
3907 }
3908 9u32 => {
3909 if tag.wire_type() != ::buffa::encoding::WireType::Varint {
3910 return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
3911 field_number: 9u32,
3912 expected: 0u8,
3913 actual: tag.wire_type() as u8,
3914 });
3915 }
3916 let __raw = ::buffa::types::decode_int32(buf)?;
3917 if let ::core::option::Option::Some(__v) = ::buffa::Enumeration::from_i32(
3918 __raw,
3919 ) {
3920 self.optimize_for = ::core::option::Option::Some(__v);
3921 } else {
3922 self.__buffa_unknown_fields
3923 .push(::buffa::UnknownField {
3924 number: 9u32,
3925 data: ::buffa::UnknownFieldData::Varint(__raw as u64),
3926 });
3927 }
3928 }
3929 11u32 => {
3930 if tag.wire_type() != ::buffa::encoding::WireType::LengthDelimited {
3931 return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
3932 field_number: 11u32,
3933 expected: 2u8,
3934 actual: tag.wire_type() as u8,
3935 });
3936 }
3937 ::buffa::types::merge_string(
3938 self
3939 .go_package
3940 .get_or_insert_with(::buffa::alloc::string::String::new),
3941 buf,
3942 )?;
3943 }
3944 16u32 => {
3945 if tag.wire_type() != ::buffa::encoding::WireType::Varint {
3946 return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
3947 field_number: 16u32,
3948 expected: 0u8,
3949 actual: tag.wire_type() as u8,
3950 });
3951 }
3952 self.cc_generic_services = ::core::option::Option::Some(
3953 ::buffa::types::decode_bool(buf)?,
3954 );
3955 }
3956 17u32 => {
3957 if tag.wire_type() != ::buffa::encoding::WireType::Varint {
3958 return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
3959 field_number: 17u32,
3960 expected: 0u8,
3961 actual: tag.wire_type() as u8,
3962 });
3963 }
3964 self.java_generic_services = ::core::option::Option::Some(
3965 ::buffa::types::decode_bool(buf)?,
3966 );
3967 }
3968 18u32 => {
3969 if tag.wire_type() != ::buffa::encoding::WireType::Varint {
3970 return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
3971 field_number: 18u32,
3972 expected: 0u8,
3973 actual: tag.wire_type() as u8,
3974 });
3975 }
3976 self.py_generic_services = ::core::option::Option::Some(
3977 ::buffa::types::decode_bool(buf)?,
3978 );
3979 }
3980 23u32 => {
3981 if tag.wire_type() != ::buffa::encoding::WireType::Varint {
3982 return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
3983 field_number: 23u32,
3984 expected: 0u8,
3985 actual: tag.wire_type() as u8,
3986 });
3987 }
3988 self.deprecated = ::core::option::Option::Some(
3989 ::buffa::types::decode_bool(buf)?,
3990 );
3991 }
3992 31u32 => {
3993 if tag.wire_type() != ::buffa::encoding::WireType::Varint {
3994 return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
3995 field_number: 31u32,
3996 expected: 0u8,
3997 actual: tag.wire_type() as u8,
3998 });
3999 }
4000 self.cc_enable_arenas = ::core::option::Option::Some(
4001 ::buffa::types::decode_bool(buf)?,
4002 );
4003 }
4004 36u32 => {
4005 if tag.wire_type() != ::buffa::encoding::WireType::LengthDelimited {
4006 return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
4007 field_number: 36u32,
4008 expected: 2u8,
4009 actual: tag.wire_type() as u8,
4010 });
4011 }
4012 ::buffa::types::merge_string(
4013 self
4014 .objc_class_prefix
4015 .get_or_insert_with(::buffa::alloc::string::String::new),
4016 buf,
4017 )?;
4018 }
4019 37u32 => {
4020 if tag.wire_type() != ::buffa::encoding::WireType::LengthDelimited {
4021 return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
4022 field_number: 37u32,
4023 expected: 2u8,
4024 actual: tag.wire_type() as u8,
4025 });
4026 }
4027 ::buffa::types::merge_string(
4028 self
4029 .csharp_namespace
4030 .get_or_insert_with(::buffa::alloc::string::String::new),
4031 buf,
4032 )?;
4033 }
4034 39u32 => {
4035 if tag.wire_type() != ::buffa::encoding::WireType::LengthDelimited {
4036 return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
4037 field_number: 39u32,
4038 expected: 2u8,
4039 actual: tag.wire_type() as u8,
4040 });
4041 }
4042 ::buffa::types::merge_string(
4043 self
4044 .swift_prefix
4045 .get_or_insert_with(::buffa::alloc::string::String::new),
4046 buf,
4047 )?;
4048 }
4049 40u32 => {
4050 if tag.wire_type() != ::buffa::encoding::WireType::LengthDelimited {
4051 return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
4052 field_number: 40u32,
4053 expected: 2u8,
4054 actual: tag.wire_type() as u8,
4055 });
4056 }
4057 ::buffa::types::merge_string(
4058 self
4059 .php_class_prefix
4060 .get_or_insert_with(::buffa::alloc::string::String::new),
4061 buf,
4062 )?;
4063 }
4064 41u32 => {
4065 if tag.wire_type() != ::buffa::encoding::WireType::LengthDelimited {
4066 return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
4067 field_number: 41u32,
4068 expected: 2u8,
4069 actual: tag.wire_type() as u8,
4070 });
4071 }
4072 ::buffa::types::merge_string(
4073 self
4074 .php_namespace
4075 .get_or_insert_with(::buffa::alloc::string::String::new),
4076 buf,
4077 )?;
4078 }
4079 44u32 => {
4080 if tag.wire_type() != ::buffa::encoding::WireType::LengthDelimited {
4081 return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
4082 field_number: 44u32,
4083 expected: 2u8,
4084 actual: tag.wire_type() as u8,
4085 });
4086 }
4087 ::buffa::types::merge_string(
4088 self
4089 .php_metadata_namespace
4090 .get_or_insert_with(::buffa::alloc::string::String::new),
4091 buf,
4092 )?;
4093 }
4094 45u32 => {
4095 if tag.wire_type() != ::buffa::encoding::WireType::LengthDelimited {
4096 return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
4097 field_number: 45u32,
4098 expected: 2u8,
4099 actual: tag.wire_type() as u8,
4100 });
4101 }
4102 ::buffa::types::merge_string(
4103 self
4104 .ruby_package
4105 .get_or_insert_with(::buffa::alloc::string::String::new),
4106 buf,
4107 )?;
4108 }
4109 50u32 => {
4110 if tag.wire_type() != ::buffa::encoding::WireType::LengthDelimited {
4111 return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
4112 field_number: 50u32,
4113 expected: 2u8,
4114 actual: tag.wire_type() as u8,
4115 });
4116 }
4117 ::buffa::Message::merge_length_delimited(
4118 self.features.get_or_insert_default(),
4119 buf,
4120 depth,
4121 )?;
4122 }
4123 999u32 => {
4124 if tag.wire_type() != ::buffa::encoding::WireType::LengthDelimited {
4125 return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
4126 field_number: 999u32,
4127 expected: 2u8,
4128 actual: tag.wire_type() as u8,
4129 });
4130 }
4131 let mut elem = ::core::default::Default::default();
4132 ::buffa::Message::merge_length_delimited(&mut elem, buf, depth)?;
4133 self.uninterpreted_option.push(elem);
4134 }
4135 _ => {
4136 self.__buffa_unknown_fields
4137 .push(::buffa::encoding::decode_unknown_field(tag, buf, depth)?);
4138 }
4139 }
4140 ::core::result::Result::Ok(())
4141 }
4142 fn cached_size(&self) -> u32 {
4143 self.__buffa_cached_size.get()
4144 }
4145 fn clear(&mut self) {
4146 self.java_package = ::core::option::Option::None;
4147 self.java_outer_classname = ::core::option::Option::None;
4148 self.java_multiple_files = ::core::option::Option::None;
4149 self.java_generate_equals_and_hash = ::core::option::Option::None;
4150 self.java_string_check_utf8 = ::core::option::Option::None;
4151 self.optimize_for = ::core::option::Option::None;
4152 self.go_package = ::core::option::Option::None;
4153 self.cc_generic_services = ::core::option::Option::None;
4154 self.java_generic_services = ::core::option::Option::None;
4155 self.py_generic_services = ::core::option::Option::None;
4156 self.deprecated = ::core::option::Option::None;
4157 self.cc_enable_arenas = ::core::option::Option::None;
4158 self.objc_class_prefix = ::core::option::Option::None;
4159 self.csharp_namespace = ::core::option::Option::None;
4160 self.swift_prefix = ::core::option::Option::None;
4161 self.php_class_prefix = ::core::option::Option::None;
4162 self.php_namespace = ::core::option::Option::None;
4163 self.php_metadata_namespace = ::core::option::Option::None;
4164 self.ruby_package = ::core::option::Option::None;
4165 self.features = ::buffa::MessageField::none();
4166 self.uninterpreted_option.clear();
4167 self.__buffa_unknown_fields.clear();
4168 self.__buffa_cached_size.set(0);
4169 }
4170}
4171pub mod file_options {
4172 #[allow(unused_imports)]
4173 use super::*;
4174 #[derive(Clone, Copy, PartialEq, Eq, Hash, Debug)]
4175 #[repr(i32)]
4176 pub enum OptimizeMode {
4177 SPEED = 1i32,
4178 CODE_SIZE = 2i32,
4179 LITE_RUNTIME = 3i32,
4180 }
4181 impl ::core::default::Default for OptimizeMode {
4182 fn default() -> Self {
4183 Self::SPEED
4184 }
4185 }
4186 impl ::buffa::Enumeration for OptimizeMode {
4187 fn from_i32(value: i32) -> ::core::option::Option<Self> {
4188 match value {
4189 1i32 => ::core::option::Option::Some(Self::SPEED),
4190 2i32 => ::core::option::Option::Some(Self::CODE_SIZE),
4191 3i32 => ::core::option::Option::Some(Self::LITE_RUNTIME),
4192 _ => ::core::option::Option::None,
4193 }
4194 }
4195 fn to_i32(&self) -> i32 {
4196 *self as i32
4197 }
4198 fn proto_name(&self) -> &'static str {
4199 match self {
4200 Self::SPEED => "SPEED",
4201 Self::CODE_SIZE => "CODE_SIZE",
4202 Self::LITE_RUNTIME => "LITE_RUNTIME",
4203 }
4204 }
4205 fn from_proto_name(name: &str) -> ::core::option::Option<Self> {
4206 match name {
4207 "SPEED" => ::core::option::Option::Some(Self::SPEED),
4208 "CODE_SIZE" => ::core::option::Option::Some(Self::CODE_SIZE),
4209 "LITE_RUNTIME" => ::core::option::Option::Some(Self::LITE_RUNTIME),
4210 _ => ::core::option::Option::None,
4211 }
4212 }
4213 }
4214}
4215#[derive(Clone, PartialEq, Default)]
4216pub struct MessageOptions {
4217 pub message_set_wire_format: Option<bool>,
4219 pub no_standard_descriptor_accessor: Option<bool>,
4221 pub deprecated: Option<bool>,
4223 pub map_entry: Option<bool>,
4225 pub deprecated_legacy_json_field_conflicts: Option<bool>,
4227 pub features: ::buffa::MessageField<FeatureSet>,
4229 pub uninterpreted_option: ::buffa::alloc::vec::Vec<UninterpretedOption>,
4231 #[doc(hidden)]
4232 pub __buffa_unknown_fields: ::buffa::UnknownFields,
4233 #[doc(hidden)]
4234 pub __buffa_cached_size: ::buffa::__private::CachedSize,
4235}
4236impl ::core::fmt::Debug for MessageOptions {
4237 fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
4238 f.debug_struct("MessageOptions")
4239 .field("message_set_wire_format", &self.message_set_wire_format)
4240 .field(
4241 "no_standard_descriptor_accessor",
4242 &self.no_standard_descriptor_accessor,
4243 )
4244 .field("deprecated", &self.deprecated)
4245 .field("map_entry", &self.map_entry)
4246 .field(
4247 "deprecated_legacy_json_field_conflicts",
4248 &self.deprecated_legacy_json_field_conflicts,
4249 )
4250 .field("features", &self.features)
4251 .field("uninterpreted_option", &self.uninterpreted_option)
4252 .finish()
4253 }
4254}
4255impl MessageOptions {
4256 pub const TYPE_URL: &'static str = "type.googleapis.com/google.protobuf.MessageOptions";
4261}
4262unsafe impl ::buffa::DefaultInstance for MessageOptions {
4263 fn default_instance() -> &'static Self {
4264 static VALUE: ::buffa::__private::OnceBox<MessageOptions> = ::buffa::__private::OnceBox::new();
4265 VALUE.get_or_init(|| ::buffa::alloc::boxed::Box::new(MessageOptions::default()))
4266 }
4267}
4268impl ::buffa::Message for MessageOptions {
4269 fn compute_size(&self) -> u32 {
4275 #[allow(unused_imports)]
4276 use ::buffa::Enumeration as _;
4277 let mut size = 0u32;
4278 if self.message_set_wire_format.is_some() {
4279 size += 1u32 + ::buffa::types::BOOL_ENCODED_LEN as u32;
4280 }
4281 if self.no_standard_descriptor_accessor.is_some() {
4282 size += 1u32 + ::buffa::types::BOOL_ENCODED_LEN as u32;
4283 }
4284 if self.deprecated.is_some() {
4285 size += 1u32 + ::buffa::types::BOOL_ENCODED_LEN as u32;
4286 }
4287 if self.map_entry.is_some() {
4288 size += 1u32 + ::buffa::types::BOOL_ENCODED_LEN as u32;
4289 }
4290 if self.deprecated_legacy_json_field_conflicts.is_some() {
4291 size += 1u32 + ::buffa::types::BOOL_ENCODED_LEN as u32;
4292 }
4293 if self.features.is_set() {
4294 let inner_size = self.features.compute_size();
4295 size
4296 += 1u32 + ::buffa::encoding::varint_len(inner_size as u64) as u32
4297 + inner_size;
4298 }
4299 for v in &self.uninterpreted_option {
4300 let inner_size = v.compute_size();
4301 size
4302 += 2u32 + ::buffa::encoding::varint_len(inner_size as u64) as u32
4303 + inner_size;
4304 }
4305 size += self.__buffa_unknown_fields.encoded_len() as u32;
4306 self.__buffa_cached_size.set(size);
4307 size
4308 }
4309 fn write_to(&self, buf: &mut impl ::buffa::bytes::BufMut) {
4310 #[allow(unused_imports)]
4311 use ::buffa::Enumeration as _;
4312 if let Some(v) = self.message_set_wire_format {
4313 ::buffa::encoding::Tag::new(1u32, ::buffa::encoding::WireType::Varint)
4314 .encode(buf);
4315 ::buffa::types::encode_bool(v, buf);
4316 }
4317 if let Some(v) = self.no_standard_descriptor_accessor {
4318 ::buffa::encoding::Tag::new(2u32, ::buffa::encoding::WireType::Varint)
4319 .encode(buf);
4320 ::buffa::types::encode_bool(v, buf);
4321 }
4322 if let Some(v) = self.deprecated {
4323 ::buffa::encoding::Tag::new(3u32, ::buffa::encoding::WireType::Varint)
4324 .encode(buf);
4325 ::buffa::types::encode_bool(v, buf);
4326 }
4327 if let Some(v) = self.map_entry {
4328 ::buffa::encoding::Tag::new(7u32, ::buffa::encoding::WireType::Varint)
4329 .encode(buf);
4330 ::buffa::types::encode_bool(v, buf);
4331 }
4332 if let Some(v) = self.deprecated_legacy_json_field_conflicts {
4333 ::buffa::encoding::Tag::new(11u32, ::buffa::encoding::WireType::Varint)
4334 .encode(buf);
4335 ::buffa::types::encode_bool(v, buf);
4336 }
4337 if self.features.is_set() {
4338 ::buffa::encoding::Tag::new(
4339 12u32,
4340 ::buffa::encoding::WireType::LengthDelimited,
4341 )
4342 .encode(buf);
4343 ::buffa::encoding::encode_varint(self.features.cached_size() as u64, buf);
4344 self.features.write_to(buf);
4345 }
4346 for v in &self.uninterpreted_option {
4347 ::buffa::encoding::Tag::new(
4348 999u32,
4349 ::buffa::encoding::WireType::LengthDelimited,
4350 )
4351 .encode(buf);
4352 ::buffa::encoding::encode_varint(v.cached_size() as u64, buf);
4353 v.write_to(buf);
4354 }
4355 self.__buffa_unknown_fields.write_to(buf);
4356 }
4357 fn merge_field(
4358 &mut self,
4359 tag: ::buffa::encoding::Tag,
4360 buf: &mut impl ::buffa::bytes::Buf,
4361 depth: u32,
4362 ) -> ::core::result::Result<(), ::buffa::DecodeError> {
4363 #[allow(unused_imports)]
4364 use ::buffa::bytes::Buf as _;
4365 #[allow(unused_imports)]
4366 use ::buffa::Enumeration as _;
4367 match tag.field_number() {
4368 1u32 => {
4369 if tag.wire_type() != ::buffa::encoding::WireType::Varint {
4370 return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
4371 field_number: 1u32,
4372 expected: 0u8,
4373 actual: tag.wire_type() as u8,
4374 });
4375 }
4376 self.message_set_wire_format = ::core::option::Option::Some(
4377 ::buffa::types::decode_bool(buf)?,
4378 );
4379 }
4380 2u32 => {
4381 if tag.wire_type() != ::buffa::encoding::WireType::Varint {
4382 return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
4383 field_number: 2u32,
4384 expected: 0u8,
4385 actual: tag.wire_type() as u8,
4386 });
4387 }
4388 self.no_standard_descriptor_accessor = ::core::option::Option::Some(
4389 ::buffa::types::decode_bool(buf)?,
4390 );
4391 }
4392 3u32 => {
4393 if tag.wire_type() != ::buffa::encoding::WireType::Varint {
4394 return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
4395 field_number: 3u32,
4396 expected: 0u8,
4397 actual: tag.wire_type() as u8,
4398 });
4399 }
4400 self.deprecated = ::core::option::Option::Some(
4401 ::buffa::types::decode_bool(buf)?,
4402 );
4403 }
4404 7u32 => {
4405 if tag.wire_type() != ::buffa::encoding::WireType::Varint {
4406 return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
4407 field_number: 7u32,
4408 expected: 0u8,
4409 actual: tag.wire_type() as u8,
4410 });
4411 }
4412 self.map_entry = ::core::option::Option::Some(
4413 ::buffa::types::decode_bool(buf)?,
4414 );
4415 }
4416 11u32 => {
4417 if tag.wire_type() != ::buffa::encoding::WireType::Varint {
4418 return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
4419 field_number: 11u32,
4420 expected: 0u8,
4421 actual: tag.wire_type() as u8,
4422 });
4423 }
4424 self.deprecated_legacy_json_field_conflicts = ::core::option::Option::Some(
4425 ::buffa::types::decode_bool(buf)?,
4426 );
4427 }
4428 12u32 => {
4429 if tag.wire_type() != ::buffa::encoding::WireType::LengthDelimited {
4430 return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
4431 field_number: 12u32,
4432 expected: 2u8,
4433 actual: tag.wire_type() as u8,
4434 });
4435 }
4436 ::buffa::Message::merge_length_delimited(
4437 self.features.get_or_insert_default(),
4438 buf,
4439 depth,
4440 )?;
4441 }
4442 999u32 => {
4443 if tag.wire_type() != ::buffa::encoding::WireType::LengthDelimited {
4444 return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
4445 field_number: 999u32,
4446 expected: 2u8,
4447 actual: tag.wire_type() as u8,
4448 });
4449 }
4450 let mut elem = ::core::default::Default::default();
4451 ::buffa::Message::merge_length_delimited(&mut elem, buf, depth)?;
4452 self.uninterpreted_option.push(elem);
4453 }
4454 _ => {
4455 self.__buffa_unknown_fields
4456 .push(::buffa::encoding::decode_unknown_field(tag, buf, depth)?);
4457 }
4458 }
4459 ::core::result::Result::Ok(())
4460 }
4461 fn cached_size(&self) -> u32 {
4462 self.__buffa_cached_size.get()
4463 }
4464 fn clear(&mut self) {
4465 self.message_set_wire_format = ::core::option::Option::None;
4466 self.no_standard_descriptor_accessor = ::core::option::Option::None;
4467 self.deprecated = ::core::option::Option::None;
4468 self.map_entry = ::core::option::Option::None;
4469 self.deprecated_legacy_json_field_conflicts = ::core::option::Option::None;
4470 self.features = ::buffa::MessageField::none();
4471 self.uninterpreted_option.clear();
4472 self.__buffa_unknown_fields.clear();
4473 self.__buffa_cached_size.set(0);
4474 }
4475}
4476#[derive(Clone, PartialEq, Default)]
4477pub struct FieldOptions {
4478 pub ctype: Option<field_options::CType>,
4480 pub packed: Option<bool>,
4482 pub jstype: Option<field_options::JSType>,
4484 pub lazy: Option<bool>,
4486 pub unverified_lazy: Option<bool>,
4488 pub deprecated: Option<bool>,
4490 pub weak: Option<bool>,
4492 pub debug_redact: Option<bool>,
4494 pub retention: Option<field_options::OptionRetention>,
4496 pub targets: ::buffa::alloc::vec::Vec<field_options::OptionTargetType>,
4498 pub edition_defaults: ::buffa::alloc::vec::Vec<field_options::EditionDefault>,
4500 pub features: ::buffa::MessageField<FeatureSet>,
4502 pub feature_support: ::buffa::MessageField<field_options::FeatureSupport>,
4504 pub uninterpreted_option: ::buffa::alloc::vec::Vec<UninterpretedOption>,
4506 #[doc(hidden)]
4507 pub __buffa_unknown_fields: ::buffa::UnknownFields,
4508 #[doc(hidden)]
4509 pub __buffa_cached_size: ::buffa::__private::CachedSize,
4510}
4511impl ::core::fmt::Debug for FieldOptions {
4512 fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
4513 f.debug_struct("FieldOptions")
4514 .field("ctype", &self.ctype)
4515 .field("packed", &self.packed)
4516 .field("jstype", &self.jstype)
4517 .field("lazy", &self.lazy)
4518 .field("unverified_lazy", &self.unverified_lazy)
4519 .field("deprecated", &self.deprecated)
4520 .field("weak", &self.weak)
4521 .field("debug_redact", &self.debug_redact)
4522 .field("retention", &self.retention)
4523 .field("targets", &self.targets)
4524 .field("edition_defaults", &self.edition_defaults)
4525 .field("features", &self.features)
4526 .field("feature_support", &self.feature_support)
4527 .field("uninterpreted_option", &self.uninterpreted_option)
4528 .finish()
4529 }
4530}
4531impl FieldOptions {
4532 pub const TYPE_URL: &'static str = "type.googleapis.com/google.protobuf.FieldOptions";
4537}
4538unsafe impl ::buffa::DefaultInstance for FieldOptions {
4539 fn default_instance() -> &'static Self {
4540 static VALUE: ::buffa::__private::OnceBox<FieldOptions> = ::buffa::__private::OnceBox::new();
4541 VALUE.get_or_init(|| ::buffa::alloc::boxed::Box::new(FieldOptions::default()))
4542 }
4543}
4544impl ::buffa::Message for FieldOptions {
4545 fn compute_size(&self) -> u32 {
4551 #[allow(unused_imports)]
4552 use ::buffa::Enumeration as _;
4553 let mut size = 0u32;
4554 if let Some(ref v) = self.ctype {
4555 size += 1u32 + ::buffa::types::int32_encoded_len(v.to_i32()) as u32;
4556 }
4557 if self.packed.is_some() {
4558 size += 1u32 + ::buffa::types::BOOL_ENCODED_LEN as u32;
4559 }
4560 if let Some(ref v) = self.jstype {
4561 size += 1u32 + ::buffa::types::int32_encoded_len(v.to_i32()) as u32;
4562 }
4563 if self.lazy.is_some() {
4564 size += 1u32 + ::buffa::types::BOOL_ENCODED_LEN as u32;
4565 }
4566 if self.unverified_lazy.is_some() {
4567 size += 1u32 + ::buffa::types::BOOL_ENCODED_LEN as u32;
4568 }
4569 if self.deprecated.is_some() {
4570 size += 1u32 + ::buffa::types::BOOL_ENCODED_LEN as u32;
4571 }
4572 if self.weak.is_some() {
4573 size += 1u32 + ::buffa::types::BOOL_ENCODED_LEN as u32;
4574 }
4575 if self.debug_redact.is_some() {
4576 size += 2u32 + ::buffa::types::BOOL_ENCODED_LEN as u32;
4577 }
4578 if let Some(ref v) = self.retention {
4579 size += 2u32 + ::buffa::types::int32_encoded_len(v.to_i32()) as u32;
4580 }
4581 if self.features.is_set() {
4582 let inner_size = self.features.compute_size();
4583 size
4584 += 2u32 + ::buffa::encoding::varint_len(inner_size as u64) as u32
4585 + inner_size;
4586 }
4587 if self.feature_support.is_set() {
4588 let inner_size = self.feature_support.compute_size();
4589 size
4590 += 2u32 + ::buffa::encoding::varint_len(inner_size as u64) as u32
4591 + inner_size;
4592 }
4593 for v in &self.targets {
4594 size += 2u32 + ::buffa::types::int32_encoded_len(v.to_i32()) as u32;
4595 }
4596 for v in &self.edition_defaults {
4597 let inner_size = v.compute_size();
4598 size
4599 += 2u32 + ::buffa::encoding::varint_len(inner_size as u64) as u32
4600 + inner_size;
4601 }
4602 for v in &self.uninterpreted_option {
4603 let inner_size = v.compute_size();
4604 size
4605 += 2u32 + ::buffa::encoding::varint_len(inner_size as u64) as u32
4606 + inner_size;
4607 }
4608 size += self.__buffa_unknown_fields.encoded_len() as u32;
4609 self.__buffa_cached_size.set(size);
4610 size
4611 }
4612 fn write_to(&self, buf: &mut impl ::buffa::bytes::BufMut) {
4613 #[allow(unused_imports)]
4614 use ::buffa::Enumeration as _;
4615 if let Some(ref v) = self.ctype {
4616 ::buffa::encoding::Tag::new(1u32, ::buffa::encoding::WireType::Varint)
4617 .encode(buf);
4618 ::buffa::types::encode_int32(v.to_i32(), buf);
4619 }
4620 if let Some(v) = self.packed {
4621 ::buffa::encoding::Tag::new(2u32, ::buffa::encoding::WireType::Varint)
4622 .encode(buf);
4623 ::buffa::types::encode_bool(v, buf);
4624 }
4625 if let Some(ref v) = self.jstype {
4626 ::buffa::encoding::Tag::new(6u32, ::buffa::encoding::WireType::Varint)
4627 .encode(buf);
4628 ::buffa::types::encode_int32(v.to_i32(), buf);
4629 }
4630 if let Some(v) = self.lazy {
4631 ::buffa::encoding::Tag::new(5u32, ::buffa::encoding::WireType::Varint)
4632 .encode(buf);
4633 ::buffa::types::encode_bool(v, buf);
4634 }
4635 if let Some(v) = self.unverified_lazy {
4636 ::buffa::encoding::Tag::new(15u32, ::buffa::encoding::WireType::Varint)
4637 .encode(buf);
4638 ::buffa::types::encode_bool(v, buf);
4639 }
4640 if let Some(v) = self.deprecated {
4641 ::buffa::encoding::Tag::new(3u32, ::buffa::encoding::WireType::Varint)
4642 .encode(buf);
4643 ::buffa::types::encode_bool(v, buf);
4644 }
4645 if let Some(v) = self.weak {
4646 ::buffa::encoding::Tag::new(10u32, ::buffa::encoding::WireType::Varint)
4647 .encode(buf);
4648 ::buffa::types::encode_bool(v, buf);
4649 }
4650 if let Some(v) = self.debug_redact {
4651 ::buffa::encoding::Tag::new(16u32, ::buffa::encoding::WireType::Varint)
4652 .encode(buf);
4653 ::buffa::types::encode_bool(v, buf);
4654 }
4655 if let Some(ref v) = self.retention {
4656 ::buffa::encoding::Tag::new(17u32, ::buffa::encoding::WireType::Varint)
4657 .encode(buf);
4658 ::buffa::types::encode_int32(v.to_i32(), buf);
4659 }
4660 if self.features.is_set() {
4661 ::buffa::encoding::Tag::new(
4662 21u32,
4663 ::buffa::encoding::WireType::LengthDelimited,
4664 )
4665 .encode(buf);
4666 ::buffa::encoding::encode_varint(self.features.cached_size() as u64, buf);
4667 self.features.write_to(buf);
4668 }
4669 if self.feature_support.is_set() {
4670 ::buffa::encoding::Tag::new(
4671 22u32,
4672 ::buffa::encoding::WireType::LengthDelimited,
4673 )
4674 .encode(buf);
4675 ::buffa::encoding::encode_varint(
4676 self.feature_support.cached_size() as u64,
4677 buf,
4678 );
4679 self.feature_support.write_to(buf);
4680 }
4681 for v in &self.targets {
4682 ::buffa::encoding::Tag::new(19u32, ::buffa::encoding::WireType::Varint)
4683 .encode(buf);
4684 ::buffa::types::encode_int32(v.to_i32(), buf);
4685 }
4686 for v in &self.edition_defaults {
4687 ::buffa::encoding::Tag::new(
4688 20u32,
4689 ::buffa::encoding::WireType::LengthDelimited,
4690 )
4691 .encode(buf);
4692 ::buffa::encoding::encode_varint(v.cached_size() as u64, buf);
4693 v.write_to(buf);
4694 }
4695 for v in &self.uninterpreted_option {
4696 ::buffa::encoding::Tag::new(
4697 999u32,
4698 ::buffa::encoding::WireType::LengthDelimited,
4699 )
4700 .encode(buf);
4701 ::buffa::encoding::encode_varint(v.cached_size() as u64, buf);
4702 v.write_to(buf);
4703 }
4704 self.__buffa_unknown_fields.write_to(buf);
4705 }
4706 fn merge_field(
4707 &mut self,
4708 tag: ::buffa::encoding::Tag,
4709 buf: &mut impl ::buffa::bytes::Buf,
4710 depth: u32,
4711 ) -> ::core::result::Result<(), ::buffa::DecodeError> {
4712 #[allow(unused_imports)]
4713 use ::buffa::bytes::Buf as _;
4714 #[allow(unused_imports)]
4715 use ::buffa::Enumeration as _;
4716 match tag.field_number() {
4717 1u32 => {
4718 if tag.wire_type() != ::buffa::encoding::WireType::Varint {
4719 return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
4720 field_number: 1u32,
4721 expected: 0u8,
4722 actual: tag.wire_type() as u8,
4723 });
4724 }
4725 let __raw = ::buffa::types::decode_int32(buf)?;
4726 if let ::core::option::Option::Some(__v) = ::buffa::Enumeration::from_i32(
4727 __raw,
4728 ) {
4729 self.ctype = ::core::option::Option::Some(__v);
4730 } else {
4731 self.__buffa_unknown_fields
4732 .push(::buffa::UnknownField {
4733 number: 1u32,
4734 data: ::buffa::UnknownFieldData::Varint(__raw as u64),
4735 });
4736 }
4737 }
4738 2u32 => {
4739 if tag.wire_type() != ::buffa::encoding::WireType::Varint {
4740 return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
4741 field_number: 2u32,
4742 expected: 0u8,
4743 actual: tag.wire_type() as u8,
4744 });
4745 }
4746 self.packed = ::core::option::Option::Some(
4747 ::buffa::types::decode_bool(buf)?,
4748 );
4749 }
4750 6u32 => {
4751 if tag.wire_type() != ::buffa::encoding::WireType::Varint {
4752 return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
4753 field_number: 6u32,
4754 expected: 0u8,
4755 actual: tag.wire_type() as u8,
4756 });
4757 }
4758 let __raw = ::buffa::types::decode_int32(buf)?;
4759 if let ::core::option::Option::Some(__v) = ::buffa::Enumeration::from_i32(
4760 __raw,
4761 ) {
4762 self.jstype = ::core::option::Option::Some(__v);
4763 } else {
4764 self.__buffa_unknown_fields
4765 .push(::buffa::UnknownField {
4766 number: 6u32,
4767 data: ::buffa::UnknownFieldData::Varint(__raw as u64),
4768 });
4769 }
4770 }
4771 5u32 => {
4772 if tag.wire_type() != ::buffa::encoding::WireType::Varint {
4773 return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
4774 field_number: 5u32,
4775 expected: 0u8,
4776 actual: tag.wire_type() as u8,
4777 });
4778 }
4779 self.lazy = ::core::option::Option::Some(
4780 ::buffa::types::decode_bool(buf)?,
4781 );
4782 }
4783 15u32 => {
4784 if tag.wire_type() != ::buffa::encoding::WireType::Varint {
4785 return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
4786 field_number: 15u32,
4787 expected: 0u8,
4788 actual: tag.wire_type() as u8,
4789 });
4790 }
4791 self.unverified_lazy = ::core::option::Option::Some(
4792 ::buffa::types::decode_bool(buf)?,
4793 );
4794 }
4795 3u32 => {
4796 if tag.wire_type() != ::buffa::encoding::WireType::Varint {
4797 return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
4798 field_number: 3u32,
4799 expected: 0u8,
4800 actual: tag.wire_type() as u8,
4801 });
4802 }
4803 self.deprecated = ::core::option::Option::Some(
4804 ::buffa::types::decode_bool(buf)?,
4805 );
4806 }
4807 10u32 => {
4808 if tag.wire_type() != ::buffa::encoding::WireType::Varint {
4809 return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
4810 field_number: 10u32,
4811 expected: 0u8,
4812 actual: tag.wire_type() as u8,
4813 });
4814 }
4815 self.weak = ::core::option::Option::Some(
4816 ::buffa::types::decode_bool(buf)?,
4817 );
4818 }
4819 16u32 => {
4820 if tag.wire_type() != ::buffa::encoding::WireType::Varint {
4821 return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
4822 field_number: 16u32,
4823 expected: 0u8,
4824 actual: tag.wire_type() as u8,
4825 });
4826 }
4827 self.debug_redact = ::core::option::Option::Some(
4828 ::buffa::types::decode_bool(buf)?,
4829 );
4830 }
4831 17u32 => {
4832 if tag.wire_type() != ::buffa::encoding::WireType::Varint {
4833 return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
4834 field_number: 17u32,
4835 expected: 0u8,
4836 actual: tag.wire_type() as u8,
4837 });
4838 }
4839 let __raw = ::buffa::types::decode_int32(buf)?;
4840 if let ::core::option::Option::Some(__v) = ::buffa::Enumeration::from_i32(
4841 __raw,
4842 ) {
4843 self.retention = ::core::option::Option::Some(__v);
4844 } else {
4845 self.__buffa_unknown_fields
4846 .push(::buffa::UnknownField {
4847 number: 17u32,
4848 data: ::buffa::UnknownFieldData::Varint(__raw as u64),
4849 });
4850 }
4851 }
4852 21u32 => {
4853 if tag.wire_type() != ::buffa::encoding::WireType::LengthDelimited {
4854 return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
4855 field_number: 21u32,
4856 expected: 2u8,
4857 actual: tag.wire_type() as u8,
4858 });
4859 }
4860 ::buffa::Message::merge_length_delimited(
4861 self.features.get_or_insert_default(),
4862 buf,
4863 depth,
4864 )?;
4865 }
4866 22u32 => {
4867 if tag.wire_type() != ::buffa::encoding::WireType::LengthDelimited {
4868 return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
4869 field_number: 22u32,
4870 expected: 2u8,
4871 actual: tag.wire_type() as u8,
4872 });
4873 }
4874 ::buffa::Message::merge_length_delimited(
4875 self.feature_support.get_or_insert_default(),
4876 buf,
4877 depth,
4878 )?;
4879 }
4880 19u32 => {
4881 if tag.wire_type() == ::buffa::encoding::WireType::LengthDelimited {
4882 let len = ::buffa::encoding::decode_varint(buf)?;
4883 let len = usize::try_from(len)
4884 .map_err(|_| ::buffa::DecodeError::MessageTooLarge)?;
4885 if buf.remaining() < len {
4886 return ::core::result::Result::Err(
4887 ::buffa::DecodeError::UnexpectedEof,
4888 );
4889 }
4890 self.targets.reserve(len);
4891 let mut limited = buf.take(len);
4892 while limited.has_remaining() {
4893 let __raw = ::buffa::types::decode_int32(&mut limited)?;
4894 if let ::core::option::Option::Some(__v) = ::buffa::Enumeration::from_i32(
4895 __raw,
4896 ) {
4897 self.targets.push(__v);
4898 } else {
4899 self.__buffa_unknown_fields
4900 .push(::buffa::UnknownField {
4901 number: 19u32,
4902 data: ::buffa::UnknownFieldData::Varint(__raw as u64),
4903 });
4904 }
4905 }
4906 let leftover = limited.remaining();
4907 if leftover > 0 {
4908 limited.advance(leftover);
4909 }
4910 } else if tag.wire_type() == ::buffa::encoding::WireType::Varint {
4911 let __raw = ::buffa::types::decode_int32(buf)?;
4912 if let ::core::option::Option::Some(__v) = ::buffa::Enumeration::from_i32(
4913 __raw,
4914 ) {
4915 self.targets.push(__v);
4916 } else {
4917 self.__buffa_unknown_fields
4918 .push(::buffa::UnknownField {
4919 number: 19u32,
4920 data: ::buffa::UnknownFieldData::Varint(__raw as u64),
4921 });
4922 }
4923 } else {
4924 return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
4925 field_number: 19u32,
4926 expected: 2u8,
4927 actual: tag.wire_type() as u8,
4928 });
4929 }
4930 }
4931 20u32 => {
4932 if tag.wire_type() != ::buffa::encoding::WireType::LengthDelimited {
4933 return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
4934 field_number: 20u32,
4935 expected: 2u8,
4936 actual: tag.wire_type() as u8,
4937 });
4938 }
4939 let mut elem = ::core::default::Default::default();
4940 ::buffa::Message::merge_length_delimited(&mut elem, buf, depth)?;
4941 self.edition_defaults.push(elem);
4942 }
4943 999u32 => {
4944 if tag.wire_type() != ::buffa::encoding::WireType::LengthDelimited {
4945 return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
4946 field_number: 999u32,
4947 expected: 2u8,
4948 actual: tag.wire_type() as u8,
4949 });
4950 }
4951 let mut elem = ::core::default::Default::default();
4952 ::buffa::Message::merge_length_delimited(&mut elem, buf, depth)?;
4953 self.uninterpreted_option.push(elem);
4954 }
4955 _ => {
4956 self.__buffa_unknown_fields
4957 .push(::buffa::encoding::decode_unknown_field(tag, buf, depth)?);
4958 }
4959 }
4960 ::core::result::Result::Ok(())
4961 }
4962 fn cached_size(&self) -> u32 {
4963 self.__buffa_cached_size.get()
4964 }
4965 fn clear(&mut self) {
4966 self.ctype = ::core::option::Option::None;
4967 self.packed = ::core::option::Option::None;
4968 self.jstype = ::core::option::Option::None;
4969 self.lazy = ::core::option::Option::None;
4970 self.unverified_lazy = ::core::option::Option::None;
4971 self.deprecated = ::core::option::Option::None;
4972 self.weak = ::core::option::Option::None;
4973 self.debug_redact = ::core::option::Option::None;
4974 self.retention = ::core::option::Option::None;
4975 self.features = ::buffa::MessageField::none();
4976 self.feature_support = ::buffa::MessageField::none();
4977 self.targets.clear();
4978 self.edition_defaults.clear();
4979 self.uninterpreted_option.clear();
4980 self.__buffa_unknown_fields.clear();
4981 self.__buffa_cached_size.set(0);
4982 }
4983}
4984pub mod field_options {
4985 #[allow(unused_imports)]
4986 use super::*;
4987 #[derive(Clone, Copy, PartialEq, Eq, Hash, Debug)]
4988 #[repr(i32)]
4989 pub enum CType {
4990 STRING = 0i32,
4991 CORD = 1i32,
4992 STRING_PIECE = 2i32,
4993 }
4994 impl ::core::default::Default for CType {
4995 fn default() -> Self {
4996 Self::STRING
4997 }
4998 }
4999 impl ::buffa::Enumeration for CType {
5000 fn from_i32(value: i32) -> ::core::option::Option<Self> {
5001 match value {
5002 0i32 => ::core::option::Option::Some(Self::STRING),
5003 1i32 => ::core::option::Option::Some(Self::CORD),
5004 2i32 => ::core::option::Option::Some(Self::STRING_PIECE),
5005 _ => ::core::option::Option::None,
5006 }
5007 }
5008 fn to_i32(&self) -> i32 {
5009 *self as i32
5010 }
5011 fn proto_name(&self) -> &'static str {
5012 match self {
5013 Self::STRING => "STRING",
5014 Self::CORD => "CORD",
5015 Self::STRING_PIECE => "STRING_PIECE",
5016 }
5017 }
5018 fn from_proto_name(name: &str) -> ::core::option::Option<Self> {
5019 match name {
5020 "STRING" => ::core::option::Option::Some(Self::STRING),
5021 "CORD" => ::core::option::Option::Some(Self::CORD),
5022 "STRING_PIECE" => ::core::option::Option::Some(Self::STRING_PIECE),
5023 _ => ::core::option::Option::None,
5024 }
5025 }
5026 }
5027 #[derive(Clone, Copy, PartialEq, Eq, Hash, Debug)]
5028 #[repr(i32)]
5029 pub enum JSType {
5030 JS_NORMAL = 0i32,
5031 JS_STRING = 1i32,
5032 JS_NUMBER = 2i32,
5033 }
5034 impl ::core::default::Default for JSType {
5035 fn default() -> Self {
5036 Self::JS_NORMAL
5037 }
5038 }
5039 impl ::buffa::Enumeration for JSType {
5040 fn from_i32(value: i32) -> ::core::option::Option<Self> {
5041 match value {
5042 0i32 => ::core::option::Option::Some(Self::JS_NORMAL),
5043 1i32 => ::core::option::Option::Some(Self::JS_STRING),
5044 2i32 => ::core::option::Option::Some(Self::JS_NUMBER),
5045 _ => ::core::option::Option::None,
5046 }
5047 }
5048 fn to_i32(&self) -> i32 {
5049 *self as i32
5050 }
5051 fn proto_name(&self) -> &'static str {
5052 match self {
5053 Self::JS_NORMAL => "JS_NORMAL",
5054 Self::JS_STRING => "JS_STRING",
5055 Self::JS_NUMBER => "JS_NUMBER",
5056 }
5057 }
5058 fn from_proto_name(name: &str) -> ::core::option::Option<Self> {
5059 match name {
5060 "JS_NORMAL" => ::core::option::Option::Some(Self::JS_NORMAL),
5061 "JS_STRING" => ::core::option::Option::Some(Self::JS_STRING),
5062 "JS_NUMBER" => ::core::option::Option::Some(Self::JS_NUMBER),
5063 _ => ::core::option::Option::None,
5064 }
5065 }
5066 }
5067 #[derive(Clone, Copy, PartialEq, Eq, Hash, Debug)]
5068 #[repr(i32)]
5069 pub enum OptionRetention {
5070 RETENTION_UNKNOWN = 0i32,
5071 RETENTION_RUNTIME = 1i32,
5072 RETENTION_SOURCE = 2i32,
5073 }
5074 impl ::core::default::Default for OptionRetention {
5075 fn default() -> Self {
5076 Self::RETENTION_UNKNOWN
5077 }
5078 }
5079 impl ::buffa::Enumeration for OptionRetention {
5080 fn from_i32(value: i32) -> ::core::option::Option<Self> {
5081 match value {
5082 0i32 => ::core::option::Option::Some(Self::RETENTION_UNKNOWN),
5083 1i32 => ::core::option::Option::Some(Self::RETENTION_RUNTIME),
5084 2i32 => ::core::option::Option::Some(Self::RETENTION_SOURCE),
5085 _ => ::core::option::Option::None,
5086 }
5087 }
5088 fn to_i32(&self) -> i32 {
5089 *self as i32
5090 }
5091 fn proto_name(&self) -> &'static str {
5092 match self {
5093 Self::RETENTION_UNKNOWN => "RETENTION_UNKNOWN",
5094 Self::RETENTION_RUNTIME => "RETENTION_RUNTIME",
5095 Self::RETENTION_SOURCE => "RETENTION_SOURCE",
5096 }
5097 }
5098 fn from_proto_name(name: &str) -> ::core::option::Option<Self> {
5099 match name {
5100 "RETENTION_UNKNOWN" => {
5101 ::core::option::Option::Some(Self::RETENTION_UNKNOWN)
5102 }
5103 "RETENTION_RUNTIME" => {
5104 ::core::option::Option::Some(Self::RETENTION_RUNTIME)
5105 }
5106 "RETENTION_SOURCE" => {
5107 ::core::option::Option::Some(Self::RETENTION_SOURCE)
5108 }
5109 _ => ::core::option::Option::None,
5110 }
5111 }
5112 }
5113 #[derive(Clone, Copy, PartialEq, Eq, Hash, Debug)]
5114 #[repr(i32)]
5115 pub enum OptionTargetType {
5116 TARGET_TYPE_UNKNOWN = 0i32,
5117 TARGET_TYPE_FILE = 1i32,
5118 TARGET_TYPE_EXTENSION_RANGE = 2i32,
5119 TARGET_TYPE_MESSAGE = 3i32,
5120 TARGET_TYPE_FIELD = 4i32,
5121 TARGET_TYPE_ONEOF = 5i32,
5122 TARGET_TYPE_ENUM = 6i32,
5123 TARGET_TYPE_ENUM_ENTRY = 7i32,
5124 TARGET_TYPE_SERVICE = 8i32,
5125 TARGET_TYPE_METHOD = 9i32,
5126 }
5127 impl ::core::default::Default for OptionTargetType {
5128 fn default() -> Self {
5129 Self::TARGET_TYPE_UNKNOWN
5130 }
5131 }
5132 impl ::buffa::Enumeration for OptionTargetType {
5133 fn from_i32(value: i32) -> ::core::option::Option<Self> {
5134 match value {
5135 0i32 => ::core::option::Option::Some(Self::TARGET_TYPE_UNKNOWN),
5136 1i32 => ::core::option::Option::Some(Self::TARGET_TYPE_FILE),
5137 2i32 => ::core::option::Option::Some(Self::TARGET_TYPE_EXTENSION_RANGE),
5138 3i32 => ::core::option::Option::Some(Self::TARGET_TYPE_MESSAGE),
5139 4i32 => ::core::option::Option::Some(Self::TARGET_TYPE_FIELD),
5140 5i32 => ::core::option::Option::Some(Self::TARGET_TYPE_ONEOF),
5141 6i32 => ::core::option::Option::Some(Self::TARGET_TYPE_ENUM),
5142 7i32 => ::core::option::Option::Some(Self::TARGET_TYPE_ENUM_ENTRY),
5143 8i32 => ::core::option::Option::Some(Self::TARGET_TYPE_SERVICE),
5144 9i32 => ::core::option::Option::Some(Self::TARGET_TYPE_METHOD),
5145 _ => ::core::option::Option::None,
5146 }
5147 }
5148 fn to_i32(&self) -> i32 {
5149 *self as i32
5150 }
5151 fn proto_name(&self) -> &'static str {
5152 match self {
5153 Self::TARGET_TYPE_UNKNOWN => "TARGET_TYPE_UNKNOWN",
5154 Self::TARGET_TYPE_FILE => "TARGET_TYPE_FILE",
5155 Self::TARGET_TYPE_EXTENSION_RANGE => "TARGET_TYPE_EXTENSION_RANGE",
5156 Self::TARGET_TYPE_MESSAGE => "TARGET_TYPE_MESSAGE",
5157 Self::TARGET_TYPE_FIELD => "TARGET_TYPE_FIELD",
5158 Self::TARGET_TYPE_ONEOF => "TARGET_TYPE_ONEOF",
5159 Self::TARGET_TYPE_ENUM => "TARGET_TYPE_ENUM",
5160 Self::TARGET_TYPE_ENUM_ENTRY => "TARGET_TYPE_ENUM_ENTRY",
5161 Self::TARGET_TYPE_SERVICE => "TARGET_TYPE_SERVICE",
5162 Self::TARGET_TYPE_METHOD => "TARGET_TYPE_METHOD",
5163 }
5164 }
5165 fn from_proto_name(name: &str) -> ::core::option::Option<Self> {
5166 match name {
5167 "TARGET_TYPE_UNKNOWN" => {
5168 ::core::option::Option::Some(Self::TARGET_TYPE_UNKNOWN)
5169 }
5170 "TARGET_TYPE_FILE" => {
5171 ::core::option::Option::Some(Self::TARGET_TYPE_FILE)
5172 }
5173 "TARGET_TYPE_EXTENSION_RANGE" => {
5174 ::core::option::Option::Some(Self::TARGET_TYPE_EXTENSION_RANGE)
5175 }
5176 "TARGET_TYPE_MESSAGE" => {
5177 ::core::option::Option::Some(Self::TARGET_TYPE_MESSAGE)
5178 }
5179 "TARGET_TYPE_FIELD" => {
5180 ::core::option::Option::Some(Self::TARGET_TYPE_FIELD)
5181 }
5182 "TARGET_TYPE_ONEOF" => {
5183 ::core::option::Option::Some(Self::TARGET_TYPE_ONEOF)
5184 }
5185 "TARGET_TYPE_ENUM" => {
5186 ::core::option::Option::Some(Self::TARGET_TYPE_ENUM)
5187 }
5188 "TARGET_TYPE_ENUM_ENTRY" => {
5189 ::core::option::Option::Some(Self::TARGET_TYPE_ENUM_ENTRY)
5190 }
5191 "TARGET_TYPE_SERVICE" => {
5192 ::core::option::Option::Some(Self::TARGET_TYPE_SERVICE)
5193 }
5194 "TARGET_TYPE_METHOD" => {
5195 ::core::option::Option::Some(Self::TARGET_TYPE_METHOD)
5196 }
5197 _ => ::core::option::Option::None,
5198 }
5199 }
5200 }
5201 #[derive(Clone, PartialEq, Default)]
5202 pub struct EditionDefault {
5203 pub edition: Option<Edition>,
5205 pub value: Option<::buffa::alloc::string::String>,
5207 #[doc(hidden)]
5208 pub __buffa_unknown_fields: ::buffa::UnknownFields,
5209 #[doc(hidden)]
5210 pub __buffa_cached_size: ::buffa::__private::CachedSize,
5211 }
5212 impl ::core::fmt::Debug for EditionDefault {
5213 fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
5214 f.debug_struct("EditionDefault")
5215 .field("edition", &self.edition)
5216 .field("value", &self.value)
5217 .finish()
5218 }
5219 }
5220 impl EditionDefault {
5221 pub const TYPE_URL: &'static str = "type.googleapis.com/google.protobuf.FieldOptions.EditionDefault";
5226 }
5227 unsafe impl ::buffa::DefaultInstance for EditionDefault {
5228 fn default_instance() -> &'static Self {
5229 static VALUE: ::buffa::__private::OnceBox<EditionDefault> = ::buffa::__private::OnceBox::new();
5230 VALUE
5231 .get_or_init(|| ::buffa::alloc::boxed::Box::new(
5232 EditionDefault::default(),
5233 ))
5234 }
5235 }
5236 impl ::buffa::Message for EditionDefault {
5237 fn compute_size(&self) -> u32 {
5243 #[allow(unused_imports)]
5244 use ::buffa::Enumeration as _;
5245 let mut size = 0u32;
5246 if let Some(ref v) = self.edition {
5247 size += 1u32 + ::buffa::types::int32_encoded_len(v.to_i32()) as u32;
5248 }
5249 if let Some(ref v) = self.value {
5250 size += 1u32 + ::buffa::types::string_encoded_len(v) as u32;
5251 }
5252 size += self.__buffa_unknown_fields.encoded_len() as u32;
5253 self.__buffa_cached_size.set(size);
5254 size
5255 }
5256 fn write_to(&self, buf: &mut impl ::buffa::bytes::BufMut) {
5257 #[allow(unused_imports)]
5258 use ::buffa::Enumeration as _;
5259 if let Some(ref v) = self.edition {
5260 ::buffa::encoding::Tag::new(3u32, ::buffa::encoding::WireType::Varint)
5261 .encode(buf);
5262 ::buffa::types::encode_int32(v.to_i32(), buf);
5263 }
5264 if let Some(ref v) = self.value {
5265 ::buffa::encoding::Tag::new(
5266 2u32,
5267 ::buffa::encoding::WireType::LengthDelimited,
5268 )
5269 .encode(buf);
5270 ::buffa::types::encode_string(v, buf);
5271 }
5272 self.__buffa_unknown_fields.write_to(buf);
5273 }
5274 fn merge_field(
5275 &mut self,
5276 tag: ::buffa::encoding::Tag,
5277 buf: &mut impl ::buffa::bytes::Buf,
5278 depth: u32,
5279 ) -> ::core::result::Result<(), ::buffa::DecodeError> {
5280 #[allow(unused_imports)]
5281 use ::buffa::bytes::Buf as _;
5282 #[allow(unused_imports)]
5283 use ::buffa::Enumeration as _;
5284 match tag.field_number() {
5285 3u32 => {
5286 if tag.wire_type() != ::buffa::encoding::WireType::Varint {
5287 return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
5288 field_number: 3u32,
5289 expected: 0u8,
5290 actual: tag.wire_type() as u8,
5291 });
5292 }
5293 let __raw = ::buffa::types::decode_int32(buf)?;
5294 if let ::core::option::Option::Some(__v) = ::buffa::Enumeration::from_i32(
5295 __raw,
5296 ) {
5297 self.edition = ::core::option::Option::Some(__v);
5298 } else {
5299 self.__buffa_unknown_fields
5300 .push(::buffa::UnknownField {
5301 number: 3u32,
5302 data: ::buffa::UnknownFieldData::Varint(__raw as u64),
5303 });
5304 }
5305 }
5306 2u32 => {
5307 if tag.wire_type() != ::buffa::encoding::WireType::LengthDelimited {
5308 return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
5309 field_number: 2u32,
5310 expected: 2u8,
5311 actual: tag.wire_type() as u8,
5312 });
5313 }
5314 ::buffa::types::merge_string(
5315 self
5316 .value
5317 .get_or_insert_with(::buffa::alloc::string::String::new),
5318 buf,
5319 )?;
5320 }
5321 _ => {
5322 self.__buffa_unknown_fields
5323 .push(::buffa::encoding::decode_unknown_field(tag, buf, depth)?);
5324 }
5325 }
5326 ::core::result::Result::Ok(())
5327 }
5328 fn cached_size(&self) -> u32 {
5329 self.__buffa_cached_size.get()
5330 }
5331 fn clear(&mut self) {
5332 self.edition = ::core::option::Option::None;
5333 self.value = ::core::option::Option::None;
5334 self.__buffa_unknown_fields.clear();
5335 self.__buffa_cached_size.set(0);
5336 }
5337 }
5338 #[derive(Clone, PartialEq, Default)]
5339 pub struct FeatureSupport {
5340 pub edition_introduced: Option<Edition>,
5342 pub edition_deprecated: Option<Edition>,
5344 pub deprecation_warning: Option<::buffa::alloc::string::String>,
5346 pub edition_removed: Option<Edition>,
5348 #[doc(hidden)]
5349 pub __buffa_unknown_fields: ::buffa::UnknownFields,
5350 #[doc(hidden)]
5351 pub __buffa_cached_size: ::buffa::__private::CachedSize,
5352 }
5353 impl ::core::fmt::Debug for FeatureSupport {
5354 fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
5355 f.debug_struct("FeatureSupport")
5356 .field("edition_introduced", &self.edition_introduced)
5357 .field("edition_deprecated", &self.edition_deprecated)
5358 .field("deprecation_warning", &self.deprecation_warning)
5359 .field("edition_removed", &self.edition_removed)
5360 .finish()
5361 }
5362 }
5363 impl FeatureSupport {
5364 pub const TYPE_URL: &'static str = "type.googleapis.com/google.protobuf.FieldOptions.FeatureSupport";
5369 }
5370 unsafe impl ::buffa::DefaultInstance for FeatureSupport {
5371 fn default_instance() -> &'static Self {
5372 static VALUE: ::buffa::__private::OnceBox<FeatureSupport> = ::buffa::__private::OnceBox::new();
5373 VALUE
5374 .get_or_init(|| ::buffa::alloc::boxed::Box::new(
5375 FeatureSupport::default(),
5376 ))
5377 }
5378 }
5379 impl ::buffa::Message for FeatureSupport {
5380 fn compute_size(&self) -> u32 {
5386 #[allow(unused_imports)]
5387 use ::buffa::Enumeration as _;
5388 let mut size = 0u32;
5389 if let Some(ref v) = self.edition_introduced {
5390 size += 1u32 + ::buffa::types::int32_encoded_len(v.to_i32()) as u32;
5391 }
5392 if let Some(ref v) = self.edition_deprecated {
5393 size += 1u32 + ::buffa::types::int32_encoded_len(v.to_i32()) as u32;
5394 }
5395 if let Some(ref v) = self.deprecation_warning {
5396 size += 1u32 + ::buffa::types::string_encoded_len(v) as u32;
5397 }
5398 if let Some(ref v) = self.edition_removed {
5399 size += 1u32 + ::buffa::types::int32_encoded_len(v.to_i32()) as u32;
5400 }
5401 size += self.__buffa_unknown_fields.encoded_len() as u32;
5402 self.__buffa_cached_size.set(size);
5403 size
5404 }
5405 fn write_to(&self, buf: &mut impl ::buffa::bytes::BufMut) {
5406 #[allow(unused_imports)]
5407 use ::buffa::Enumeration as _;
5408 if let Some(ref v) = self.edition_introduced {
5409 ::buffa::encoding::Tag::new(1u32, ::buffa::encoding::WireType::Varint)
5410 .encode(buf);
5411 ::buffa::types::encode_int32(v.to_i32(), buf);
5412 }
5413 if let Some(ref v) = self.edition_deprecated {
5414 ::buffa::encoding::Tag::new(2u32, ::buffa::encoding::WireType::Varint)
5415 .encode(buf);
5416 ::buffa::types::encode_int32(v.to_i32(), buf);
5417 }
5418 if let Some(ref v) = self.deprecation_warning {
5419 ::buffa::encoding::Tag::new(
5420 3u32,
5421 ::buffa::encoding::WireType::LengthDelimited,
5422 )
5423 .encode(buf);
5424 ::buffa::types::encode_string(v, buf);
5425 }
5426 if let Some(ref v) = self.edition_removed {
5427 ::buffa::encoding::Tag::new(4u32, ::buffa::encoding::WireType::Varint)
5428 .encode(buf);
5429 ::buffa::types::encode_int32(v.to_i32(), buf);
5430 }
5431 self.__buffa_unknown_fields.write_to(buf);
5432 }
5433 fn merge_field(
5434 &mut self,
5435 tag: ::buffa::encoding::Tag,
5436 buf: &mut impl ::buffa::bytes::Buf,
5437 depth: u32,
5438 ) -> ::core::result::Result<(), ::buffa::DecodeError> {
5439 #[allow(unused_imports)]
5440 use ::buffa::bytes::Buf as _;
5441 #[allow(unused_imports)]
5442 use ::buffa::Enumeration as _;
5443 match tag.field_number() {
5444 1u32 => {
5445 if tag.wire_type() != ::buffa::encoding::WireType::Varint {
5446 return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
5447 field_number: 1u32,
5448 expected: 0u8,
5449 actual: tag.wire_type() as u8,
5450 });
5451 }
5452 let __raw = ::buffa::types::decode_int32(buf)?;
5453 if let ::core::option::Option::Some(__v) = ::buffa::Enumeration::from_i32(
5454 __raw,
5455 ) {
5456 self.edition_introduced = ::core::option::Option::Some(__v);
5457 } else {
5458 self.__buffa_unknown_fields
5459 .push(::buffa::UnknownField {
5460 number: 1u32,
5461 data: ::buffa::UnknownFieldData::Varint(__raw as u64),
5462 });
5463 }
5464 }
5465 2u32 => {
5466 if tag.wire_type() != ::buffa::encoding::WireType::Varint {
5467 return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
5468 field_number: 2u32,
5469 expected: 0u8,
5470 actual: tag.wire_type() as u8,
5471 });
5472 }
5473 let __raw = ::buffa::types::decode_int32(buf)?;
5474 if let ::core::option::Option::Some(__v) = ::buffa::Enumeration::from_i32(
5475 __raw,
5476 ) {
5477 self.edition_deprecated = ::core::option::Option::Some(__v);
5478 } else {
5479 self.__buffa_unknown_fields
5480 .push(::buffa::UnknownField {
5481 number: 2u32,
5482 data: ::buffa::UnknownFieldData::Varint(__raw as u64),
5483 });
5484 }
5485 }
5486 3u32 => {
5487 if tag.wire_type() != ::buffa::encoding::WireType::LengthDelimited {
5488 return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
5489 field_number: 3u32,
5490 expected: 2u8,
5491 actual: tag.wire_type() as u8,
5492 });
5493 }
5494 ::buffa::types::merge_string(
5495 self
5496 .deprecation_warning
5497 .get_or_insert_with(::buffa::alloc::string::String::new),
5498 buf,
5499 )?;
5500 }
5501 4u32 => {
5502 if tag.wire_type() != ::buffa::encoding::WireType::Varint {
5503 return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
5504 field_number: 4u32,
5505 expected: 0u8,
5506 actual: tag.wire_type() as u8,
5507 });
5508 }
5509 let __raw = ::buffa::types::decode_int32(buf)?;
5510 if let ::core::option::Option::Some(__v) = ::buffa::Enumeration::from_i32(
5511 __raw,
5512 ) {
5513 self.edition_removed = ::core::option::Option::Some(__v);
5514 } else {
5515 self.__buffa_unknown_fields
5516 .push(::buffa::UnknownField {
5517 number: 4u32,
5518 data: ::buffa::UnknownFieldData::Varint(__raw as u64),
5519 });
5520 }
5521 }
5522 _ => {
5523 self.__buffa_unknown_fields
5524 .push(::buffa::encoding::decode_unknown_field(tag, buf, depth)?);
5525 }
5526 }
5527 ::core::result::Result::Ok(())
5528 }
5529 fn cached_size(&self) -> u32 {
5530 self.__buffa_cached_size.get()
5531 }
5532 fn clear(&mut self) {
5533 self.edition_introduced = ::core::option::Option::None;
5534 self.edition_deprecated = ::core::option::Option::None;
5535 self.deprecation_warning = ::core::option::Option::None;
5536 self.edition_removed = ::core::option::Option::None;
5537 self.__buffa_unknown_fields.clear();
5538 self.__buffa_cached_size.set(0);
5539 }
5540 }
5541}
5542#[derive(Clone, PartialEq, Default)]
5543pub struct OneofOptions {
5544 pub features: ::buffa::MessageField<FeatureSet>,
5546 pub uninterpreted_option: ::buffa::alloc::vec::Vec<UninterpretedOption>,
5548 #[doc(hidden)]
5549 pub __buffa_unknown_fields: ::buffa::UnknownFields,
5550 #[doc(hidden)]
5551 pub __buffa_cached_size: ::buffa::__private::CachedSize,
5552}
5553impl ::core::fmt::Debug for OneofOptions {
5554 fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
5555 f.debug_struct("OneofOptions")
5556 .field("features", &self.features)
5557 .field("uninterpreted_option", &self.uninterpreted_option)
5558 .finish()
5559 }
5560}
5561impl OneofOptions {
5562 pub const TYPE_URL: &'static str = "type.googleapis.com/google.protobuf.OneofOptions";
5567}
5568unsafe impl ::buffa::DefaultInstance for OneofOptions {
5569 fn default_instance() -> &'static Self {
5570 static VALUE: ::buffa::__private::OnceBox<OneofOptions> = ::buffa::__private::OnceBox::new();
5571 VALUE.get_or_init(|| ::buffa::alloc::boxed::Box::new(OneofOptions::default()))
5572 }
5573}
5574impl ::buffa::Message for OneofOptions {
5575 fn compute_size(&self) -> u32 {
5581 #[allow(unused_imports)]
5582 use ::buffa::Enumeration as _;
5583 let mut size = 0u32;
5584 if self.features.is_set() {
5585 let inner_size = self.features.compute_size();
5586 size
5587 += 1u32 + ::buffa::encoding::varint_len(inner_size as u64) as u32
5588 + inner_size;
5589 }
5590 for v in &self.uninterpreted_option {
5591 let inner_size = v.compute_size();
5592 size
5593 += 2u32 + ::buffa::encoding::varint_len(inner_size as u64) as u32
5594 + inner_size;
5595 }
5596 size += self.__buffa_unknown_fields.encoded_len() as u32;
5597 self.__buffa_cached_size.set(size);
5598 size
5599 }
5600 fn write_to(&self, buf: &mut impl ::buffa::bytes::BufMut) {
5601 #[allow(unused_imports)]
5602 use ::buffa::Enumeration as _;
5603 if self.features.is_set() {
5604 ::buffa::encoding::Tag::new(
5605 1u32,
5606 ::buffa::encoding::WireType::LengthDelimited,
5607 )
5608 .encode(buf);
5609 ::buffa::encoding::encode_varint(self.features.cached_size() as u64, buf);
5610 self.features.write_to(buf);
5611 }
5612 for v in &self.uninterpreted_option {
5613 ::buffa::encoding::Tag::new(
5614 999u32,
5615 ::buffa::encoding::WireType::LengthDelimited,
5616 )
5617 .encode(buf);
5618 ::buffa::encoding::encode_varint(v.cached_size() as u64, buf);
5619 v.write_to(buf);
5620 }
5621 self.__buffa_unknown_fields.write_to(buf);
5622 }
5623 fn merge_field(
5624 &mut self,
5625 tag: ::buffa::encoding::Tag,
5626 buf: &mut impl ::buffa::bytes::Buf,
5627 depth: u32,
5628 ) -> ::core::result::Result<(), ::buffa::DecodeError> {
5629 #[allow(unused_imports)]
5630 use ::buffa::bytes::Buf as _;
5631 #[allow(unused_imports)]
5632 use ::buffa::Enumeration as _;
5633 match tag.field_number() {
5634 1u32 => {
5635 if tag.wire_type() != ::buffa::encoding::WireType::LengthDelimited {
5636 return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
5637 field_number: 1u32,
5638 expected: 2u8,
5639 actual: tag.wire_type() as u8,
5640 });
5641 }
5642 ::buffa::Message::merge_length_delimited(
5643 self.features.get_or_insert_default(),
5644 buf,
5645 depth,
5646 )?;
5647 }
5648 999u32 => {
5649 if tag.wire_type() != ::buffa::encoding::WireType::LengthDelimited {
5650 return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
5651 field_number: 999u32,
5652 expected: 2u8,
5653 actual: tag.wire_type() as u8,
5654 });
5655 }
5656 let mut elem = ::core::default::Default::default();
5657 ::buffa::Message::merge_length_delimited(&mut elem, buf, depth)?;
5658 self.uninterpreted_option.push(elem);
5659 }
5660 _ => {
5661 self.__buffa_unknown_fields
5662 .push(::buffa::encoding::decode_unknown_field(tag, buf, depth)?);
5663 }
5664 }
5665 ::core::result::Result::Ok(())
5666 }
5667 fn cached_size(&self) -> u32 {
5668 self.__buffa_cached_size.get()
5669 }
5670 fn clear(&mut self) {
5671 self.features = ::buffa::MessageField::none();
5672 self.uninterpreted_option.clear();
5673 self.__buffa_unknown_fields.clear();
5674 self.__buffa_cached_size.set(0);
5675 }
5676}
5677#[derive(Clone, PartialEq, Default)]
5678pub struct EnumOptions {
5679 pub allow_alias: Option<bool>,
5681 pub deprecated: Option<bool>,
5683 pub deprecated_legacy_json_field_conflicts: Option<bool>,
5685 pub features: ::buffa::MessageField<FeatureSet>,
5687 pub uninterpreted_option: ::buffa::alloc::vec::Vec<UninterpretedOption>,
5689 #[doc(hidden)]
5690 pub __buffa_unknown_fields: ::buffa::UnknownFields,
5691 #[doc(hidden)]
5692 pub __buffa_cached_size: ::buffa::__private::CachedSize,
5693}
5694impl ::core::fmt::Debug for EnumOptions {
5695 fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
5696 f.debug_struct("EnumOptions")
5697 .field("allow_alias", &self.allow_alias)
5698 .field("deprecated", &self.deprecated)
5699 .field(
5700 "deprecated_legacy_json_field_conflicts",
5701 &self.deprecated_legacy_json_field_conflicts,
5702 )
5703 .field("features", &self.features)
5704 .field("uninterpreted_option", &self.uninterpreted_option)
5705 .finish()
5706 }
5707}
5708impl EnumOptions {
5709 pub const TYPE_URL: &'static str = "type.googleapis.com/google.protobuf.EnumOptions";
5714}
5715unsafe impl ::buffa::DefaultInstance for EnumOptions {
5716 fn default_instance() -> &'static Self {
5717 static VALUE: ::buffa::__private::OnceBox<EnumOptions> = ::buffa::__private::OnceBox::new();
5718 VALUE.get_or_init(|| ::buffa::alloc::boxed::Box::new(EnumOptions::default()))
5719 }
5720}
5721impl ::buffa::Message for EnumOptions {
5722 fn compute_size(&self) -> u32 {
5728 #[allow(unused_imports)]
5729 use ::buffa::Enumeration as _;
5730 let mut size = 0u32;
5731 if self.allow_alias.is_some() {
5732 size += 1u32 + ::buffa::types::BOOL_ENCODED_LEN as u32;
5733 }
5734 if self.deprecated.is_some() {
5735 size += 1u32 + ::buffa::types::BOOL_ENCODED_LEN as u32;
5736 }
5737 if self.deprecated_legacy_json_field_conflicts.is_some() {
5738 size += 1u32 + ::buffa::types::BOOL_ENCODED_LEN as u32;
5739 }
5740 if self.features.is_set() {
5741 let inner_size = self.features.compute_size();
5742 size
5743 += 1u32 + ::buffa::encoding::varint_len(inner_size as u64) as u32
5744 + inner_size;
5745 }
5746 for v in &self.uninterpreted_option {
5747 let inner_size = v.compute_size();
5748 size
5749 += 2u32 + ::buffa::encoding::varint_len(inner_size as u64) as u32
5750 + inner_size;
5751 }
5752 size += self.__buffa_unknown_fields.encoded_len() as u32;
5753 self.__buffa_cached_size.set(size);
5754 size
5755 }
5756 fn write_to(&self, buf: &mut impl ::buffa::bytes::BufMut) {
5757 #[allow(unused_imports)]
5758 use ::buffa::Enumeration as _;
5759 if let Some(v) = self.allow_alias {
5760 ::buffa::encoding::Tag::new(2u32, ::buffa::encoding::WireType::Varint)
5761 .encode(buf);
5762 ::buffa::types::encode_bool(v, buf);
5763 }
5764 if let Some(v) = self.deprecated {
5765 ::buffa::encoding::Tag::new(3u32, ::buffa::encoding::WireType::Varint)
5766 .encode(buf);
5767 ::buffa::types::encode_bool(v, buf);
5768 }
5769 if let Some(v) = self.deprecated_legacy_json_field_conflicts {
5770 ::buffa::encoding::Tag::new(6u32, ::buffa::encoding::WireType::Varint)
5771 .encode(buf);
5772 ::buffa::types::encode_bool(v, buf);
5773 }
5774 if self.features.is_set() {
5775 ::buffa::encoding::Tag::new(
5776 7u32,
5777 ::buffa::encoding::WireType::LengthDelimited,
5778 )
5779 .encode(buf);
5780 ::buffa::encoding::encode_varint(self.features.cached_size() as u64, buf);
5781 self.features.write_to(buf);
5782 }
5783 for v in &self.uninterpreted_option {
5784 ::buffa::encoding::Tag::new(
5785 999u32,
5786 ::buffa::encoding::WireType::LengthDelimited,
5787 )
5788 .encode(buf);
5789 ::buffa::encoding::encode_varint(v.cached_size() as u64, buf);
5790 v.write_to(buf);
5791 }
5792 self.__buffa_unknown_fields.write_to(buf);
5793 }
5794 fn merge_field(
5795 &mut self,
5796 tag: ::buffa::encoding::Tag,
5797 buf: &mut impl ::buffa::bytes::Buf,
5798 depth: u32,
5799 ) -> ::core::result::Result<(), ::buffa::DecodeError> {
5800 #[allow(unused_imports)]
5801 use ::buffa::bytes::Buf as _;
5802 #[allow(unused_imports)]
5803 use ::buffa::Enumeration as _;
5804 match tag.field_number() {
5805 2u32 => {
5806 if tag.wire_type() != ::buffa::encoding::WireType::Varint {
5807 return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
5808 field_number: 2u32,
5809 expected: 0u8,
5810 actual: tag.wire_type() as u8,
5811 });
5812 }
5813 self.allow_alias = ::core::option::Option::Some(
5814 ::buffa::types::decode_bool(buf)?,
5815 );
5816 }
5817 3u32 => {
5818 if tag.wire_type() != ::buffa::encoding::WireType::Varint {
5819 return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
5820 field_number: 3u32,
5821 expected: 0u8,
5822 actual: tag.wire_type() as u8,
5823 });
5824 }
5825 self.deprecated = ::core::option::Option::Some(
5826 ::buffa::types::decode_bool(buf)?,
5827 );
5828 }
5829 6u32 => {
5830 if tag.wire_type() != ::buffa::encoding::WireType::Varint {
5831 return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
5832 field_number: 6u32,
5833 expected: 0u8,
5834 actual: tag.wire_type() as u8,
5835 });
5836 }
5837 self.deprecated_legacy_json_field_conflicts = ::core::option::Option::Some(
5838 ::buffa::types::decode_bool(buf)?,
5839 );
5840 }
5841 7u32 => {
5842 if tag.wire_type() != ::buffa::encoding::WireType::LengthDelimited {
5843 return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
5844 field_number: 7u32,
5845 expected: 2u8,
5846 actual: tag.wire_type() as u8,
5847 });
5848 }
5849 ::buffa::Message::merge_length_delimited(
5850 self.features.get_or_insert_default(),
5851 buf,
5852 depth,
5853 )?;
5854 }
5855 999u32 => {
5856 if tag.wire_type() != ::buffa::encoding::WireType::LengthDelimited {
5857 return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
5858 field_number: 999u32,
5859 expected: 2u8,
5860 actual: tag.wire_type() as u8,
5861 });
5862 }
5863 let mut elem = ::core::default::Default::default();
5864 ::buffa::Message::merge_length_delimited(&mut elem, buf, depth)?;
5865 self.uninterpreted_option.push(elem);
5866 }
5867 _ => {
5868 self.__buffa_unknown_fields
5869 .push(::buffa::encoding::decode_unknown_field(tag, buf, depth)?);
5870 }
5871 }
5872 ::core::result::Result::Ok(())
5873 }
5874 fn cached_size(&self) -> u32 {
5875 self.__buffa_cached_size.get()
5876 }
5877 fn clear(&mut self) {
5878 self.allow_alias = ::core::option::Option::None;
5879 self.deprecated = ::core::option::Option::None;
5880 self.deprecated_legacy_json_field_conflicts = ::core::option::Option::None;
5881 self.features = ::buffa::MessageField::none();
5882 self.uninterpreted_option.clear();
5883 self.__buffa_unknown_fields.clear();
5884 self.__buffa_cached_size.set(0);
5885 }
5886}
5887#[derive(Clone, PartialEq, Default)]
5888pub struct EnumValueOptions {
5889 pub deprecated: Option<bool>,
5891 pub features: ::buffa::MessageField<FeatureSet>,
5893 pub debug_redact: Option<bool>,
5895 pub feature_support: ::buffa::MessageField<field_options::FeatureSupport>,
5897 pub uninterpreted_option: ::buffa::alloc::vec::Vec<UninterpretedOption>,
5899 #[doc(hidden)]
5900 pub __buffa_unknown_fields: ::buffa::UnknownFields,
5901 #[doc(hidden)]
5902 pub __buffa_cached_size: ::buffa::__private::CachedSize,
5903}
5904impl ::core::fmt::Debug for EnumValueOptions {
5905 fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
5906 f.debug_struct("EnumValueOptions")
5907 .field("deprecated", &self.deprecated)
5908 .field("features", &self.features)
5909 .field("debug_redact", &self.debug_redact)
5910 .field("feature_support", &self.feature_support)
5911 .field("uninterpreted_option", &self.uninterpreted_option)
5912 .finish()
5913 }
5914}
5915impl EnumValueOptions {
5916 pub const TYPE_URL: &'static str = "type.googleapis.com/google.protobuf.EnumValueOptions";
5921}
5922unsafe impl ::buffa::DefaultInstance for EnumValueOptions {
5923 fn default_instance() -> &'static Self {
5924 static VALUE: ::buffa::__private::OnceBox<EnumValueOptions> = ::buffa::__private::OnceBox::new();
5925 VALUE
5926 .get_or_init(|| ::buffa::alloc::boxed::Box::new(EnumValueOptions::default()))
5927 }
5928}
5929impl ::buffa::Message for EnumValueOptions {
5930 fn compute_size(&self) -> u32 {
5936 #[allow(unused_imports)]
5937 use ::buffa::Enumeration as _;
5938 let mut size = 0u32;
5939 if self.deprecated.is_some() {
5940 size += 1u32 + ::buffa::types::BOOL_ENCODED_LEN as u32;
5941 }
5942 if self.features.is_set() {
5943 let inner_size = self.features.compute_size();
5944 size
5945 += 1u32 + ::buffa::encoding::varint_len(inner_size as u64) as u32
5946 + inner_size;
5947 }
5948 if self.debug_redact.is_some() {
5949 size += 1u32 + ::buffa::types::BOOL_ENCODED_LEN as u32;
5950 }
5951 if self.feature_support.is_set() {
5952 let inner_size = self.feature_support.compute_size();
5953 size
5954 += 1u32 + ::buffa::encoding::varint_len(inner_size as u64) as u32
5955 + inner_size;
5956 }
5957 for v in &self.uninterpreted_option {
5958 let inner_size = v.compute_size();
5959 size
5960 += 2u32 + ::buffa::encoding::varint_len(inner_size as u64) as u32
5961 + inner_size;
5962 }
5963 size += self.__buffa_unknown_fields.encoded_len() as u32;
5964 self.__buffa_cached_size.set(size);
5965 size
5966 }
5967 fn write_to(&self, buf: &mut impl ::buffa::bytes::BufMut) {
5968 #[allow(unused_imports)]
5969 use ::buffa::Enumeration as _;
5970 if let Some(v) = self.deprecated {
5971 ::buffa::encoding::Tag::new(1u32, ::buffa::encoding::WireType::Varint)
5972 .encode(buf);
5973 ::buffa::types::encode_bool(v, buf);
5974 }
5975 if self.features.is_set() {
5976 ::buffa::encoding::Tag::new(
5977 2u32,
5978 ::buffa::encoding::WireType::LengthDelimited,
5979 )
5980 .encode(buf);
5981 ::buffa::encoding::encode_varint(self.features.cached_size() as u64, buf);
5982 self.features.write_to(buf);
5983 }
5984 if let Some(v) = self.debug_redact {
5985 ::buffa::encoding::Tag::new(3u32, ::buffa::encoding::WireType::Varint)
5986 .encode(buf);
5987 ::buffa::types::encode_bool(v, buf);
5988 }
5989 if self.feature_support.is_set() {
5990 ::buffa::encoding::Tag::new(
5991 4u32,
5992 ::buffa::encoding::WireType::LengthDelimited,
5993 )
5994 .encode(buf);
5995 ::buffa::encoding::encode_varint(
5996 self.feature_support.cached_size() as u64,
5997 buf,
5998 );
5999 self.feature_support.write_to(buf);
6000 }
6001 for v in &self.uninterpreted_option {
6002 ::buffa::encoding::Tag::new(
6003 999u32,
6004 ::buffa::encoding::WireType::LengthDelimited,
6005 )
6006 .encode(buf);
6007 ::buffa::encoding::encode_varint(v.cached_size() as u64, buf);
6008 v.write_to(buf);
6009 }
6010 self.__buffa_unknown_fields.write_to(buf);
6011 }
6012 fn merge_field(
6013 &mut self,
6014 tag: ::buffa::encoding::Tag,
6015 buf: &mut impl ::buffa::bytes::Buf,
6016 depth: u32,
6017 ) -> ::core::result::Result<(), ::buffa::DecodeError> {
6018 #[allow(unused_imports)]
6019 use ::buffa::bytes::Buf as _;
6020 #[allow(unused_imports)]
6021 use ::buffa::Enumeration as _;
6022 match tag.field_number() {
6023 1u32 => {
6024 if tag.wire_type() != ::buffa::encoding::WireType::Varint {
6025 return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
6026 field_number: 1u32,
6027 expected: 0u8,
6028 actual: tag.wire_type() as u8,
6029 });
6030 }
6031 self.deprecated = ::core::option::Option::Some(
6032 ::buffa::types::decode_bool(buf)?,
6033 );
6034 }
6035 2u32 => {
6036 if tag.wire_type() != ::buffa::encoding::WireType::LengthDelimited {
6037 return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
6038 field_number: 2u32,
6039 expected: 2u8,
6040 actual: tag.wire_type() as u8,
6041 });
6042 }
6043 ::buffa::Message::merge_length_delimited(
6044 self.features.get_or_insert_default(),
6045 buf,
6046 depth,
6047 )?;
6048 }
6049 3u32 => {
6050 if tag.wire_type() != ::buffa::encoding::WireType::Varint {
6051 return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
6052 field_number: 3u32,
6053 expected: 0u8,
6054 actual: tag.wire_type() as u8,
6055 });
6056 }
6057 self.debug_redact = ::core::option::Option::Some(
6058 ::buffa::types::decode_bool(buf)?,
6059 );
6060 }
6061 4u32 => {
6062 if tag.wire_type() != ::buffa::encoding::WireType::LengthDelimited {
6063 return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
6064 field_number: 4u32,
6065 expected: 2u8,
6066 actual: tag.wire_type() as u8,
6067 });
6068 }
6069 ::buffa::Message::merge_length_delimited(
6070 self.feature_support.get_or_insert_default(),
6071 buf,
6072 depth,
6073 )?;
6074 }
6075 999u32 => {
6076 if tag.wire_type() != ::buffa::encoding::WireType::LengthDelimited {
6077 return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
6078 field_number: 999u32,
6079 expected: 2u8,
6080 actual: tag.wire_type() as u8,
6081 });
6082 }
6083 let mut elem = ::core::default::Default::default();
6084 ::buffa::Message::merge_length_delimited(&mut elem, buf, depth)?;
6085 self.uninterpreted_option.push(elem);
6086 }
6087 _ => {
6088 self.__buffa_unknown_fields
6089 .push(::buffa::encoding::decode_unknown_field(tag, buf, depth)?);
6090 }
6091 }
6092 ::core::result::Result::Ok(())
6093 }
6094 fn cached_size(&self) -> u32 {
6095 self.__buffa_cached_size.get()
6096 }
6097 fn clear(&mut self) {
6098 self.deprecated = ::core::option::Option::None;
6099 self.features = ::buffa::MessageField::none();
6100 self.debug_redact = ::core::option::Option::None;
6101 self.feature_support = ::buffa::MessageField::none();
6102 self.uninterpreted_option.clear();
6103 self.__buffa_unknown_fields.clear();
6104 self.__buffa_cached_size.set(0);
6105 }
6106}
6107#[derive(Clone, PartialEq, Default)]
6108pub struct ServiceOptions {
6109 pub features: ::buffa::MessageField<FeatureSet>,
6111 pub deprecated: Option<bool>,
6113 pub uninterpreted_option: ::buffa::alloc::vec::Vec<UninterpretedOption>,
6115 #[doc(hidden)]
6116 pub __buffa_unknown_fields: ::buffa::UnknownFields,
6117 #[doc(hidden)]
6118 pub __buffa_cached_size: ::buffa::__private::CachedSize,
6119}
6120impl ::core::fmt::Debug for ServiceOptions {
6121 fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
6122 f.debug_struct("ServiceOptions")
6123 .field("features", &self.features)
6124 .field("deprecated", &self.deprecated)
6125 .field("uninterpreted_option", &self.uninterpreted_option)
6126 .finish()
6127 }
6128}
6129impl ServiceOptions {
6130 pub const TYPE_URL: &'static str = "type.googleapis.com/google.protobuf.ServiceOptions";
6135}
6136unsafe impl ::buffa::DefaultInstance for ServiceOptions {
6137 fn default_instance() -> &'static Self {
6138 static VALUE: ::buffa::__private::OnceBox<ServiceOptions> = ::buffa::__private::OnceBox::new();
6139 VALUE.get_or_init(|| ::buffa::alloc::boxed::Box::new(ServiceOptions::default()))
6140 }
6141}
6142impl ::buffa::Message for ServiceOptions {
6143 fn compute_size(&self) -> u32 {
6149 #[allow(unused_imports)]
6150 use ::buffa::Enumeration as _;
6151 let mut size = 0u32;
6152 if self.features.is_set() {
6153 let inner_size = self.features.compute_size();
6154 size
6155 += 2u32 + ::buffa::encoding::varint_len(inner_size as u64) as u32
6156 + inner_size;
6157 }
6158 if self.deprecated.is_some() {
6159 size += 2u32 + ::buffa::types::BOOL_ENCODED_LEN as u32;
6160 }
6161 for v in &self.uninterpreted_option {
6162 let inner_size = v.compute_size();
6163 size
6164 += 2u32 + ::buffa::encoding::varint_len(inner_size as u64) as u32
6165 + inner_size;
6166 }
6167 size += self.__buffa_unknown_fields.encoded_len() as u32;
6168 self.__buffa_cached_size.set(size);
6169 size
6170 }
6171 fn write_to(&self, buf: &mut impl ::buffa::bytes::BufMut) {
6172 #[allow(unused_imports)]
6173 use ::buffa::Enumeration as _;
6174 if self.features.is_set() {
6175 ::buffa::encoding::Tag::new(
6176 34u32,
6177 ::buffa::encoding::WireType::LengthDelimited,
6178 )
6179 .encode(buf);
6180 ::buffa::encoding::encode_varint(self.features.cached_size() as u64, buf);
6181 self.features.write_to(buf);
6182 }
6183 if let Some(v) = self.deprecated {
6184 ::buffa::encoding::Tag::new(33u32, ::buffa::encoding::WireType::Varint)
6185 .encode(buf);
6186 ::buffa::types::encode_bool(v, buf);
6187 }
6188 for v in &self.uninterpreted_option {
6189 ::buffa::encoding::Tag::new(
6190 999u32,
6191 ::buffa::encoding::WireType::LengthDelimited,
6192 )
6193 .encode(buf);
6194 ::buffa::encoding::encode_varint(v.cached_size() as u64, buf);
6195 v.write_to(buf);
6196 }
6197 self.__buffa_unknown_fields.write_to(buf);
6198 }
6199 fn merge_field(
6200 &mut self,
6201 tag: ::buffa::encoding::Tag,
6202 buf: &mut impl ::buffa::bytes::Buf,
6203 depth: u32,
6204 ) -> ::core::result::Result<(), ::buffa::DecodeError> {
6205 #[allow(unused_imports)]
6206 use ::buffa::bytes::Buf as _;
6207 #[allow(unused_imports)]
6208 use ::buffa::Enumeration as _;
6209 match tag.field_number() {
6210 34u32 => {
6211 if tag.wire_type() != ::buffa::encoding::WireType::LengthDelimited {
6212 return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
6213 field_number: 34u32,
6214 expected: 2u8,
6215 actual: tag.wire_type() as u8,
6216 });
6217 }
6218 ::buffa::Message::merge_length_delimited(
6219 self.features.get_or_insert_default(),
6220 buf,
6221 depth,
6222 )?;
6223 }
6224 33u32 => {
6225 if tag.wire_type() != ::buffa::encoding::WireType::Varint {
6226 return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
6227 field_number: 33u32,
6228 expected: 0u8,
6229 actual: tag.wire_type() as u8,
6230 });
6231 }
6232 self.deprecated = ::core::option::Option::Some(
6233 ::buffa::types::decode_bool(buf)?,
6234 );
6235 }
6236 999u32 => {
6237 if tag.wire_type() != ::buffa::encoding::WireType::LengthDelimited {
6238 return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
6239 field_number: 999u32,
6240 expected: 2u8,
6241 actual: tag.wire_type() as u8,
6242 });
6243 }
6244 let mut elem = ::core::default::Default::default();
6245 ::buffa::Message::merge_length_delimited(&mut elem, buf, depth)?;
6246 self.uninterpreted_option.push(elem);
6247 }
6248 _ => {
6249 self.__buffa_unknown_fields
6250 .push(::buffa::encoding::decode_unknown_field(tag, buf, depth)?);
6251 }
6252 }
6253 ::core::result::Result::Ok(())
6254 }
6255 fn cached_size(&self) -> u32 {
6256 self.__buffa_cached_size.get()
6257 }
6258 fn clear(&mut self) {
6259 self.features = ::buffa::MessageField::none();
6260 self.deprecated = ::core::option::Option::None;
6261 self.uninterpreted_option.clear();
6262 self.__buffa_unknown_fields.clear();
6263 self.__buffa_cached_size.set(0);
6264 }
6265}
6266#[derive(Clone, PartialEq, Default)]
6267pub struct MethodOptions {
6268 pub deprecated: Option<bool>,
6270 pub idempotency_level: Option<method_options::IdempotencyLevel>,
6272 pub features: ::buffa::MessageField<FeatureSet>,
6274 pub uninterpreted_option: ::buffa::alloc::vec::Vec<UninterpretedOption>,
6276 #[doc(hidden)]
6277 pub __buffa_unknown_fields: ::buffa::UnknownFields,
6278 #[doc(hidden)]
6279 pub __buffa_cached_size: ::buffa::__private::CachedSize,
6280}
6281impl ::core::fmt::Debug for MethodOptions {
6282 fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
6283 f.debug_struct("MethodOptions")
6284 .field("deprecated", &self.deprecated)
6285 .field("idempotency_level", &self.idempotency_level)
6286 .field("features", &self.features)
6287 .field("uninterpreted_option", &self.uninterpreted_option)
6288 .finish()
6289 }
6290}
6291impl MethodOptions {
6292 pub const TYPE_URL: &'static str = "type.googleapis.com/google.protobuf.MethodOptions";
6297}
6298unsafe impl ::buffa::DefaultInstance for MethodOptions {
6299 fn default_instance() -> &'static Self {
6300 static VALUE: ::buffa::__private::OnceBox<MethodOptions> = ::buffa::__private::OnceBox::new();
6301 VALUE.get_or_init(|| ::buffa::alloc::boxed::Box::new(MethodOptions::default()))
6302 }
6303}
6304impl ::buffa::Message for MethodOptions {
6305 fn compute_size(&self) -> u32 {
6311 #[allow(unused_imports)]
6312 use ::buffa::Enumeration as _;
6313 let mut size = 0u32;
6314 if self.deprecated.is_some() {
6315 size += 2u32 + ::buffa::types::BOOL_ENCODED_LEN as u32;
6316 }
6317 if let Some(ref v) = self.idempotency_level {
6318 size += 2u32 + ::buffa::types::int32_encoded_len(v.to_i32()) as u32;
6319 }
6320 if self.features.is_set() {
6321 let inner_size = self.features.compute_size();
6322 size
6323 += 2u32 + ::buffa::encoding::varint_len(inner_size as u64) as u32
6324 + inner_size;
6325 }
6326 for v in &self.uninterpreted_option {
6327 let inner_size = v.compute_size();
6328 size
6329 += 2u32 + ::buffa::encoding::varint_len(inner_size as u64) as u32
6330 + inner_size;
6331 }
6332 size += self.__buffa_unknown_fields.encoded_len() as u32;
6333 self.__buffa_cached_size.set(size);
6334 size
6335 }
6336 fn write_to(&self, buf: &mut impl ::buffa::bytes::BufMut) {
6337 #[allow(unused_imports)]
6338 use ::buffa::Enumeration as _;
6339 if let Some(v) = self.deprecated {
6340 ::buffa::encoding::Tag::new(33u32, ::buffa::encoding::WireType::Varint)
6341 .encode(buf);
6342 ::buffa::types::encode_bool(v, buf);
6343 }
6344 if let Some(ref v) = self.idempotency_level {
6345 ::buffa::encoding::Tag::new(34u32, ::buffa::encoding::WireType::Varint)
6346 .encode(buf);
6347 ::buffa::types::encode_int32(v.to_i32(), buf);
6348 }
6349 if self.features.is_set() {
6350 ::buffa::encoding::Tag::new(
6351 35u32,
6352 ::buffa::encoding::WireType::LengthDelimited,
6353 )
6354 .encode(buf);
6355 ::buffa::encoding::encode_varint(self.features.cached_size() as u64, buf);
6356 self.features.write_to(buf);
6357 }
6358 for v in &self.uninterpreted_option {
6359 ::buffa::encoding::Tag::new(
6360 999u32,
6361 ::buffa::encoding::WireType::LengthDelimited,
6362 )
6363 .encode(buf);
6364 ::buffa::encoding::encode_varint(v.cached_size() as u64, buf);
6365 v.write_to(buf);
6366 }
6367 self.__buffa_unknown_fields.write_to(buf);
6368 }
6369 fn merge_field(
6370 &mut self,
6371 tag: ::buffa::encoding::Tag,
6372 buf: &mut impl ::buffa::bytes::Buf,
6373 depth: u32,
6374 ) -> ::core::result::Result<(), ::buffa::DecodeError> {
6375 #[allow(unused_imports)]
6376 use ::buffa::bytes::Buf as _;
6377 #[allow(unused_imports)]
6378 use ::buffa::Enumeration as _;
6379 match tag.field_number() {
6380 33u32 => {
6381 if tag.wire_type() != ::buffa::encoding::WireType::Varint {
6382 return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
6383 field_number: 33u32,
6384 expected: 0u8,
6385 actual: tag.wire_type() as u8,
6386 });
6387 }
6388 self.deprecated = ::core::option::Option::Some(
6389 ::buffa::types::decode_bool(buf)?,
6390 );
6391 }
6392 34u32 => {
6393 if tag.wire_type() != ::buffa::encoding::WireType::Varint {
6394 return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
6395 field_number: 34u32,
6396 expected: 0u8,
6397 actual: tag.wire_type() as u8,
6398 });
6399 }
6400 let __raw = ::buffa::types::decode_int32(buf)?;
6401 if let ::core::option::Option::Some(__v) = ::buffa::Enumeration::from_i32(
6402 __raw,
6403 ) {
6404 self.idempotency_level = ::core::option::Option::Some(__v);
6405 } else {
6406 self.__buffa_unknown_fields
6407 .push(::buffa::UnknownField {
6408 number: 34u32,
6409 data: ::buffa::UnknownFieldData::Varint(__raw as u64),
6410 });
6411 }
6412 }
6413 35u32 => {
6414 if tag.wire_type() != ::buffa::encoding::WireType::LengthDelimited {
6415 return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
6416 field_number: 35u32,
6417 expected: 2u8,
6418 actual: tag.wire_type() as u8,
6419 });
6420 }
6421 ::buffa::Message::merge_length_delimited(
6422 self.features.get_or_insert_default(),
6423 buf,
6424 depth,
6425 )?;
6426 }
6427 999u32 => {
6428 if tag.wire_type() != ::buffa::encoding::WireType::LengthDelimited {
6429 return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
6430 field_number: 999u32,
6431 expected: 2u8,
6432 actual: tag.wire_type() as u8,
6433 });
6434 }
6435 let mut elem = ::core::default::Default::default();
6436 ::buffa::Message::merge_length_delimited(&mut elem, buf, depth)?;
6437 self.uninterpreted_option.push(elem);
6438 }
6439 _ => {
6440 self.__buffa_unknown_fields
6441 .push(::buffa::encoding::decode_unknown_field(tag, buf, depth)?);
6442 }
6443 }
6444 ::core::result::Result::Ok(())
6445 }
6446 fn cached_size(&self) -> u32 {
6447 self.__buffa_cached_size.get()
6448 }
6449 fn clear(&mut self) {
6450 self.deprecated = ::core::option::Option::None;
6451 self.idempotency_level = ::core::option::Option::None;
6452 self.features = ::buffa::MessageField::none();
6453 self.uninterpreted_option.clear();
6454 self.__buffa_unknown_fields.clear();
6455 self.__buffa_cached_size.set(0);
6456 }
6457}
6458pub mod method_options {
6459 #[allow(unused_imports)]
6460 use super::*;
6461 #[derive(Clone, Copy, PartialEq, Eq, Hash, Debug)]
6462 #[repr(i32)]
6463 pub enum IdempotencyLevel {
6464 IDEMPOTENCY_UNKNOWN = 0i32,
6465 NO_SIDE_EFFECTS = 1i32,
6466 IDEMPOTENT = 2i32,
6467 }
6468 impl ::core::default::Default for IdempotencyLevel {
6469 fn default() -> Self {
6470 Self::IDEMPOTENCY_UNKNOWN
6471 }
6472 }
6473 impl ::buffa::Enumeration for IdempotencyLevel {
6474 fn from_i32(value: i32) -> ::core::option::Option<Self> {
6475 match value {
6476 0i32 => ::core::option::Option::Some(Self::IDEMPOTENCY_UNKNOWN),
6477 1i32 => ::core::option::Option::Some(Self::NO_SIDE_EFFECTS),
6478 2i32 => ::core::option::Option::Some(Self::IDEMPOTENT),
6479 _ => ::core::option::Option::None,
6480 }
6481 }
6482 fn to_i32(&self) -> i32 {
6483 *self as i32
6484 }
6485 fn proto_name(&self) -> &'static str {
6486 match self {
6487 Self::IDEMPOTENCY_UNKNOWN => "IDEMPOTENCY_UNKNOWN",
6488 Self::NO_SIDE_EFFECTS => "NO_SIDE_EFFECTS",
6489 Self::IDEMPOTENT => "IDEMPOTENT",
6490 }
6491 }
6492 fn from_proto_name(name: &str) -> ::core::option::Option<Self> {
6493 match name {
6494 "IDEMPOTENCY_UNKNOWN" => {
6495 ::core::option::Option::Some(Self::IDEMPOTENCY_UNKNOWN)
6496 }
6497 "NO_SIDE_EFFECTS" => ::core::option::Option::Some(Self::NO_SIDE_EFFECTS),
6498 "IDEMPOTENT" => ::core::option::Option::Some(Self::IDEMPOTENT),
6499 _ => ::core::option::Option::None,
6500 }
6501 }
6502 }
6503}
6504#[derive(Clone, PartialEq, Default)]
6505pub struct UninterpretedOption {
6506 pub name: ::buffa::alloc::vec::Vec<uninterpreted_option::NamePart>,
6508 pub identifier_value: Option<::buffa::alloc::string::String>,
6510 pub positive_int_value: Option<u64>,
6512 pub negative_int_value: Option<i64>,
6514 pub double_value: Option<f64>,
6516 pub string_value: Option<::buffa::alloc::vec::Vec<u8>>,
6518 pub aggregate_value: Option<::buffa::alloc::string::String>,
6520 #[doc(hidden)]
6521 pub __buffa_unknown_fields: ::buffa::UnknownFields,
6522 #[doc(hidden)]
6523 pub __buffa_cached_size: ::buffa::__private::CachedSize,
6524}
6525impl ::core::fmt::Debug for UninterpretedOption {
6526 fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
6527 f.debug_struct("UninterpretedOption")
6528 .field("name", &self.name)
6529 .field("identifier_value", &self.identifier_value)
6530 .field("positive_int_value", &self.positive_int_value)
6531 .field("negative_int_value", &self.negative_int_value)
6532 .field("double_value", &self.double_value)
6533 .field("string_value", &self.string_value)
6534 .field("aggregate_value", &self.aggregate_value)
6535 .finish()
6536 }
6537}
6538impl UninterpretedOption {
6539 pub const TYPE_URL: &'static str = "type.googleapis.com/google.protobuf.UninterpretedOption";
6544}
6545unsafe impl ::buffa::DefaultInstance for UninterpretedOption {
6546 fn default_instance() -> &'static Self {
6547 static VALUE: ::buffa::__private::OnceBox<UninterpretedOption> = ::buffa::__private::OnceBox::new();
6548 VALUE
6549 .get_or_init(|| ::buffa::alloc::boxed::Box::new(
6550 UninterpretedOption::default(),
6551 ))
6552 }
6553}
6554impl ::buffa::Message for UninterpretedOption {
6555 fn compute_size(&self) -> u32 {
6561 #[allow(unused_imports)]
6562 use ::buffa::Enumeration as _;
6563 let mut size = 0u32;
6564 if let Some(ref v) = self.identifier_value {
6565 size += 1u32 + ::buffa::types::string_encoded_len(v) as u32;
6566 }
6567 if let Some(v) = self.positive_int_value {
6568 size += 1u32 + ::buffa::types::uint64_encoded_len(v) as u32;
6569 }
6570 if let Some(v) = self.negative_int_value {
6571 size += 1u32 + ::buffa::types::int64_encoded_len(v) as u32;
6572 }
6573 if self.double_value.is_some() {
6574 size += 1u32 + ::buffa::types::FIXED64_ENCODED_LEN as u32;
6575 }
6576 if let Some(ref v) = self.string_value {
6577 size += 1u32 + ::buffa::types::bytes_encoded_len(v) as u32;
6578 }
6579 if let Some(ref v) = self.aggregate_value {
6580 size += 1u32 + ::buffa::types::string_encoded_len(v) as u32;
6581 }
6582 for v in &self.name {
6583 let inner_size = v.compute_size();
6584 size
6585 += 1u32 + ::buffa::encoding::varint_len(inner_size as u64) as u32
6586 + inner_size;
6587 }
6588 size += self.__buffa_unknown_fields.encoded_len() as u32;
6589 self.__buffa_cached_size.set(size);
6590 size
6591 }
6592 fn write_to(&self, buf: &mut impl ::buffa::bytes::BufMut) {
6593 #[allow(unused_imports)]
6594 use ::buffa::Enumeration as _;
6595 if let Some(ref v) = self.identifier_value {
6596 ::buffa::encoding::Tag::new(
6597 3u32,
6598 ::buffa::encoding::WireType::LengthDelimited,
6599 )
6600 .encode(buf);
6601 ::buffa::types::encode_string(v, buf);
6602 }
6603 if let Some(v) = self.positive_int_value {
6604 ::buffa::encoding::Tag::new(4u32, ::buffa::encoding::WireType::Varint)
6605 .encode(buf);
6606 ::buffa::types::encode_uint64(v, buf);
6607 }
6608 if let Some(v) = self.negative_int_value {
6609 ::buffa::encoding::Tag::new(5u32, ::buffa::encoding::WireType::Varint)
6610 .encode(buf);
6611 ::buffa::types::encode_int64(v, buf);
6612 }
6613 if let Some(v) = self.double_value {
6614 ::buffa::encoding::Tag::new(6u32, ::buffa::encoding::WireType::Fixed64)
6615 .encode(buf);
6616 ::buffa::types::encode_double(v, buf);
6617 }
6618 if let Some(ref v) = self.string_value {
6619 ::buffa::encoding::Tag::new(
6620 7u32,
6621 ::buffa::encoding::WireType::LengthDelimited,
6622 )
6623 .encode(buf);
6624 ::buffa::types::encode_bytes(v, buf);
6625 }
6626 if let Some(ref v) = self.aggregate_value {
6627 ::buffa::encoding::Tag::new(
6628 8u32,
6629 ::buffa::encoding::WireType::LengthDelimited,
6630 )
6631 .encode(buf);
6632 ::buffa::types::encode_string(v, buf);
6633 }
6634 for v in &self.name {
6635 ::buffa::encoding::Tag::new(
6636 2u32,
6637 ::buffa::encoding::WireType::LengthDelimited,
6638 )
6639 .encode(buf);
6640 ::buffa::encoding::encode_varint(v.cached_size() as u64, buf);
6641 v.write_to(buf);
6642 }
6643 self.__buffa_unknown_fields.write_to(buf);
6644 }
6645 fn merge_field(
6646 &mut self,
6647 tag: ::buffa::encoding::Tag,
6648 buf: &mut impl ::buffa::bytes::Buf,
6649 depth: u32,
6650 ) -> ::core::result::Result<(), ::buffa::DecodeError> {
6651 #[allow(unused_imports)]
6652 use ::buffa::bytes::Buf as _;
6653 #[allow(unused_imports)]
6654 use ::buffa::Enumeration as _;
6655 match tag.field_number() {
6656 3u32 => {
6657 if tag.wire_type() != ::buffa::encoding::WireType::LengthDelimited {
6658 return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
6659 field_number: 3u32,
6660 expected: 2u8,
6661 actual: tag.wire_type() as u8,
6662 });
6663 }
6664 ::buffa::types::merge_string(
6665 self
6666 .identifier_value
6667 .get_or_insert_with(::buffa::alloc::string::String::new),
6668 buf,
6669 )?;
6670 }
6671 4u32 => {
6672 if tag.wire_type() != ::buffa::encoding::WireType::Varint {
6673 return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
6674 field_number: 4u32,
6675 expected: 0u8,
6676 actual: tag.wire_type() as u8,
6677 });
6678 }
6679 self.positive_int_value = ::core::option::Option::Some(
6680 ::buffa::types::decode_uint64(buf)?,
6681 );
6682 }
6683 5u32 => {
6684 if tag.wire_type() != ::buffa::encoding::WireType::Varint {
6685 return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
6686 field_number: 5u32,
6687 expected: 0u8,
6688 actual: tag.wire_type() as u8,
6689 });
6690 }
6691 self.negative_int_value = ::core::option::Option::Some(
6692 ::buffa::types::decode_int64(buf)?,
6693 );
6694 }
6695 6u32 => {
6696 if tag.wire_type() != ::buffa::encoding::WireType::Fixed64 {
6697 return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
6698 field_number: 6u32,
6699 expected: 1u8,
6700 actual: tag.wire_type() as u8,
6701 });
6702 }
6703 self.double_value = ::core::option::Option::Some(
6704 ::buffa::types::decode_double(buf)?,
6705 );
6706 }
6707 7u32 => {
6708 if tag.wire_type() != ::buffa::encoding::WireType::LengthDelimited {
6709 return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
6710 field_number: 7u32,
6711 expected: 2u8,
6712 actual: tag.wire_type() as u8,
6713 });
6714 }
6715 ::buffa::types::merge_bytes(
6716 self.string_value.get_or_insert_with(::buffa::alloc::vec::Vec::new),
6717 buf,
6718 )?;
6719 }
6720 8u32 => {
6721 if tag.wire_type() != ::buffa::encoding::WireType::LengthDelimited {
6722 return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
6723 field_number: 8u32,
6724 expected: 2u8,
6725 actual: tag.wire_type() as u8,
6726 });
6727 }
6728 ::buffa::types::merge_string(
6729 self
6730 .aggregate_value
6731 .get_or_insert_with(::buffa::alloc::string::String::new),
6732 buf,
6733 )?;
6734 }
6735 2u32 => {
6736 if tag.wire_type() != ::buffa::encoding::WireType::LengthDelimited {
6737 return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
6738 field_number: 2u32,
6739 expected: 2u8,
6740 actual: tag.wire_type() as u8,
6741 });
6742 }
6743 let mut elem = ::core::default::Default::default();
6744 ::buffa::Message::merge_length_delimited(&mut elem, buf, depth)?;
6745 self.name.push(elem);
6746 }
6747 _ => {
6748 self.__buffa_unknown_fields
6749 .push(::buffa::encoding::decode_unknown_field(tag, buf, depth)?);
6750 }
6751 }
6752 ::core::result::Result::Ok(())
6753 }
6754 fn cached_size(&self) -> u32 {
6755 self.__buffa_cached_size.get()
6756 }
6757 fn clear(&mut self) {
6758 self.identifier_value = ::core::option::Option::None;
6759 self.positive_int_value = ::core::option::Option::None;
6760 self.negative_int_value = ::core::option::Option::None;
6761 self.double_value = ::core::option::Option::None;
6762 self.string_value = ::core::option::Option::None;
6763 self.aggregate_value = ::core::option::Option::None;
6764 self.name.clear();
6765 self.__buffa_unknown_fields.clear();
6766 self.__buffa_cached_size.set(0);
6767 }
6768}
6769pub mod uninterpreted_option {
6770 #[allow(unused_imports)]
6771 use super::*;
6772 #[derive(Clone, PartialEq, Default)]
6773 pub struct NamePart {
6774 pub name_part: ::buffa::alloc::string::String,
6776 pub is_extension: bool,
6778 #[doc(hidden)]
6779 pub __buffa_unknown_fields: ::buffa::UnknownFields,
6780 #[doc(hidden)]
6781 pub __buffa_cached_size: ::buffa::__private::CachedSize,
6782 }
6783 impl ::core::fmt::Debug for NamePart {
6784 fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
6785 f.debug_struct("NamePart")
6786 .field("name_part", &self.name_part)
6787 .field("is_extension", &self.is_extension)
6788 .finish()
6789 }
6790 }
6791 impl NamePart {
6792 pub const TYPE_URL: &'static str = "type.googleapis.com/google.protobuf.UninterpretedOption.NamePart";
6797 }
6798 unsafe impl ::buffa::DefaultInstance for NamePart {
6799 fn default_instance() -> &'static Self {
6800 static VALUE: ::buffa::__private::OnceBox<NamePart> = ::buffa::__private::OnceBox::new();
6801 VALUE.get_or_init(|| ::buffa::alloc::boxed::Box::new(NamePart::default()))
6802 }
6803 }
6804 impl ::buffa::Message for NamePart {
6805 fn compute_size(&self) -> u32 {
6811 #[allow(unused_imports)]
6812 use ::buffa::Enumeration as _;
6813 let mut size = 0u32;
6814 size += 1u32 + ::buffa::types::string_encoded_len(&self.name_part) as u32;
6815 size += 1u32 + ::buffa::types::BOOL_ENCODED_LEN as u32;
6816 size += self.__buffa_unknown_fields.encoded_len() as u32;
6817 self.__buffa_cached_size.set(size);
6818 size
6819 }
6820 fn write_to(&self, buf: &mut impl ::buffa::bytes::BufMut) {
6821 #[allow(unused_imports)]
6822 use ::buffa::Enumeration as _;
6823 ::buffa::encoding::Tag::new(
6824 1u32,
6825 ::buffa::encoding::WireType::LengthDelimited,
6826 )
6827 .encode(buf);
6828 ::buffa::types::encode_string(&self.name_part, buf);
6829 ::buffa::encoding::Tag::new(2u32, ::buffa::encoding::WireType::Varint)
6830 .encode(buf);
6831 ::buffa::types::encode_bool(self.is_extension, buf);
6832 self.__buffa_unknown_fields.write_to(buf);
6833 }
6834 fn merge_field(
6835 &mut self,
6836 tag: ::buffa::encoding::Tag,
6837 buf: &mut impl ::buffa::bytes::Buf,
6838 depth: u32,
6839 ) -> ::core::result::Result<(), ::buffa::DecodeError> {
6840 #[allow(unused_imports)]
6841 use ::buffa::bytes::Buf as _;
6842 #[allow(unused_imports)]
6843 use ::buffa::Enumeration as _;
6844 match tag.field_number() {
6845 1u32 => {
6846 if tag.wire_type() != ::buffa::encoding::WireType::LengthDelimited {
6847 return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
6848 field_number: 1u32,
6849 expected: 2u8,
6850 actual: tag.wire_type() as u8,
6851 });
6852 }
6853 ::buffa::types::merge_string(&mut self.name_part, buf)?;
6854 }
6855 2u32 => {
6856 if tag.wire_type() != ::buffa::encoding::WireType::Varint {
6857 return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
6858 field_number: 2u32,
6859 expected: 0u8,
6860 actual: tag.wire_type() as u8,
6861 });
6862 }
6863 self.is_extension = ::buffa::types::decode_bool(buf)?;
6864 }
6865 _ => {
6866 self.__buffa_unknown_fields
6867 .push(::buffa::encoding::decode_unknown_field(tag, buf, depth)?);
6868 }
6869 }
6870 ::core::result::Result::Ok(())
6871 }
6872 fn cached_size(&self) -> u32 {
6873 self.__buffa_cached_size.get()
6874 }
6875 fn clear(&mut self) {
6876 self.name_part.clear();
6877 self.is_extension = false;
6878 self.__buffa_unknown_fields.clear();
6879 self.__buffa_cached_size.set(0);
6880 }
6881 }
6882}
6883#[derive(Clone, PartialEq, Default)]
6884pub struct FeatureSet {
6885 pub field_presence: Option<feature_set::FieldPresence>,
6887 pub enum_type: Option<feature_set::EnumType>,
6889 pub repeated_field_encoding: Option<feature_set::RepeatedFieldEncoding>,
6891 pub utf8_validation: Option<feature_set::Utf8Validation>,
6893 pub message_encoding: Option<feature_set::MessageEncoding>,
6895 pub json_format: Option<feature_set::JsonFormat>,
6897 pub enforce_naming_style: Option<feature_set::EnforceNamingStyle>,
6899 pub default_symbol_visibility: Option<
6901 feature_set::visibility_feature::DefaultSymbolVisibility,
6902 >,
6903 #[doc(hidden)]
6904 pub __buffa_unknown_fields: ::buffa::UnknownFields,
6905 #[doc(hidden)]
6906 pub __buffa_cached_size: ::buffa::__private::CachedSize,
6907}
6908impl ::core::fmt::Debug for FeatureSet {
6909 fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
6910 f.debug_struct("FeatureSet")
6911 .field("field_presence", &self.field_presence)
6912 .field("enum_type", &self.enum_type)
6913 .field("repeated_field_encoding", &self.repeated_field_encoding)
6914 .field("utf8_validation", &self.utf8_validation)
6915 .field("message_encoding", &self.message_encoding)
6916 .field("json_format", &self.json_format)
6917 .field("enforce_naming_style", &self.enforce_naming_style)
6918 .field("default_symbol_visibility", &self.default_symbol_visibility)
6919 .finish()
6920 }
6921}
6922impl FeatureSet {
6923 pub const TYPE_URL: &'static str = "type.googleapis.com/google.protobuf.FeatureSet";
6928}
6929unsafe impl ::buffa::DefaultInstance for FeatureSet {
6930 fn default_instance() -> &'static Self {
6931 static VALUE: ::buffa::__private::OnceBox<FeatureSet> = ::buffa::__private::OnceBox::new();
6932 VALUE.get_or_init(|| ::buffa::alloc::boxed::Box::new(FeatureSet::default()))
6933 }
6934}
6935impl ::buffa::Message for FeatureSet {
6936 fn compute_size(&self) -> u32 {
6942 #[allow(unused_imports)]
6943 use ::buffa::Enumeration as _;
6944 let mut size = 0u32;
6945 if let Some(ref v) = self.field_presence {
6946 size += 1u32 + ::buffa::types::int32_encoded_len(v.to_i32()) as u32;
6947 }
6948 if let Some(ref v) = self.enum_type {
6949 size += 1u32 + ::buffa::types::int32_encoded_len(v.to_i32()) as u32;
6950 }
6951 if let Some(ref v) = self.repeated_field_encoding {
6952 size += 1u32 + ::buffa::types::int32_encoded_len(v.to_i32()) as u32;
6953 }
6954 if let Some(ref v) = self.utf8_validation {
6955 size += 1u32 + ::buffa::types::int32_encoded_len(v.to_i32()) as u32;
6956 }
6957 if let Some(ref v) = self.message_encoding {
6958 size += 1u32 + ::buffa::types::int32_encoded_len(v.to_i32()) as u32;
6959 }
6960 if let Some(ref v) = self.json_format {
6961 size += 1u32 + ::buffa::types::int32_encoded_len(v.to_i32()) as u32;
6962 }
6963 if let Some(ref v) = self.enforce_naming_style {
6964 size += 1u32 + ::buffa::types::int32_encoded_len(v.to_i32()) as u32;
6965 }
6966 if let Some(ref v) = self.default_symbol_visibility {
6967 size += 1u32 + ::buffa::types::int32_encoded_len(v.to_i32()) as u32;
6968 }
6969 size += self.__buffa_unknown_fields.encoded_len() as u32;
6970 self.__buffa_cached_size.set(size);
6971 size
6972 }
6973 fn write_to(&self, buf: &mut impl ::buffa::bytes::BufMut) {
6974 #[allow(unused_imports)]
6975 use ::buffa::Enumeration as _;
6976 if let Some(ref v) = self.field_presence {
6977 ::buffa::encoding::Tag::new(1u32, ::buffa::encoding::WireType::Varint)
6978 .encode(buf);
6979 ::buffa::types::encode_int32(v.to_i32(), buf);
6980 }
6981 if let Some(ref v) = self.enum_type {
6982 ::buffa::encoding::Tag::new(2u32, ::buffa::encoding::WireType::Varint)
6983 .encode(buf);
6984 ::buffa::types::encode_int32(v.to_i32(), buf);
6985 }
6986 if let Some(ref v) = self.repeated_field_encoding {
6987 ::buffa::encoding::Tag::new(3u32, ::buffa::encoding::WireType::Varint)
6988 .encode(buf);
6989 ::buffa::types::encode_int32(v.to_i32(), buf);
6990 }
6991 if let Some(ref v) = self.utf8_validation {
6992 ::buffa::encoding::Tag::new(4u32, ::buffa::encoding::WireType::Varint)
6993 .encode(buf);
6994 ::buffa::types::encode_int32(v.to_i32(), buf);
6995 }
6996 if let Some(ref v) = self.message_encoding {
6997 ::buffa::encoding::Tag::new(5u32, ::buffa::encoding::WireType::Varint)
6998 .encode(buf);
6999 ::buffa::types::encode_int32(v.to_i32(), buf);
7000 }
7001 if let Some(ref v) = self.json_format {
7002 ::buffa::encoding::Tag::new(6u32, ::buffa::encoding::WireType::Varint)
7003 .encode(buf);
7004 ::buffa::types::encode_int32(v.to_i32(), buf);
7005 }
7006 if let Some(ref v) = self.enforce_naming_style {
7007 ::buffa::encoding::Tag::new(7u32, ::buffa::encoding::WireType::Varint)
7008 .encode(buf);
7009 ::buffa::types::encode_int32(v.to_i32(), buf);
7010 }
7011 if let Some(ref v) = self.default_symbol_visibility {
7012 ::buffa::encoding::Tag::new(8u32, ::buffa::encoding::WireType::Varint)
7013 .encode(buf);
7014 ::buffa::types::encode_int32(v.to_i32(), buf);
7015 }
7016 self.__buffa_unknown_fields.write_to(buf);
7017 }
7018 fn merge_field(
7019 &mut self,
7020 tag: ::buffa::encoding::Tag,
7021 buf: &mut impl ::buffa::bytes::Buf,
7022 depth: u32,
7023 ) -> ::core::result::Result<(), ::buffa::DecodeError> {
7024 #[allow(unused_imports)]
7025 use ::buffa::bytes::Buf as _;
7026 #[allow(unused_imports)]
7027 use ::buffa::Enumeration as _;
7028 match tag.field_number() {
7029 1u32 => {
7030 if tag.wire_type() != ::buffa::encoding::WireType::Varint {
7031 return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
7032 field_number: 1u32,
7033 expected: 0u8,
7034 actual: tag.wire_type() as u8,
7035 });
7036 }
7037 let __raw = ::buffa::types::decode_int32(buf)?;
7038 if let ::core::option::Option::Some(__v) = ::buffa::Enumeration::from_i32(
7039 __raw,
7040 ) {
7041 self.field_presence = ::core::option::Option::Some(__v);
7042 } else {
7043 self.__buffa_unknown_fields
7044 .push(::buffa::UnknownField {
7045 number: 1u32,
7046 data: ::buffa::UnknownFieldData::Varint(__raw as u64),
7047 });
7048 }
7049 }
7050 2u32 => {
7051 if tag.wire_type() != ::buffa::encoding::WireType::Varint {
7052 return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
7053 field_number: 2u32,
7054 expected: 0u8,
7055 actual: tag.wire_type() as u8,
7056 });
7057 }
7058 let __raw = ::buffa::types::decode_int32(buf)?;
7059 if let ::core::option::Option::Some(__v) = ::buffa::Enumeration::from_i32(
7060 __raw,
7061 ) {
7062 self.enum_type = ::core::option::Option::Some(__v);
7063 } else {
7064 self.__buffa_unknown_fields
7065 .push(::buffa::UnknownField {
7066 number: 2u32,
7067 data: ::buffa::UnknownFieldData::Varint(__raw as u64),
7068 });
7069 }
7070 }
7071 3u32 => {
7072 if tag.wire_type() != ::buffa::encoding::WireType::Varint {
7073 return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
7074 field_number: 3u32,
7075 expected: 0u8,
7076 actual: tag.wire_type() as u8,
7077 });
7078 }
7079 let __raw = ::buffa::types::decode_int32(buf)?;
7080 if let ::core::option::Option::Some(__v) = ::buffa::Enumeration::from_i32(
7081 __raw,
7082 ) {
7083 self.repeated_field_encoding = ::core::option::Option::Some(__v);
7084 } else {
7085 self.__buffa_unknown_fields
7086 .push(::buffa::UnknownField {
7087 number: 3u32,
7088 data: ::buffa::UnknownFieldData::Varint(__raw as u64),
7089 });
7090 }
7091 }
7092 4u32 => {
7093 if tag.wire_type() != ::buffa::encoding::WireType::Varint {
7094 return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
7095 field_number: 4u32,
7096 expected: 0u8,
7097 actual: tag.wire_type() as u8,
7098 });
7099 }
7100 let __raw = ::buffa::types::decode_int32(buf)?;
7101 if let ::core::option::Option::Some(__v) = ::buffa::Enumeration::from_i32(
7102 __raw,
7103 ) {
7104 self.utf8_validation = ::core::option::Option::Some(__v);
7105 } else {
7106 self.__buffa_unknown_fields
7107 .push(::buffa::UnknownField {
7108 number: 4u32,
7109 data: ::buffa::UnknownFieldData::Varint(__raw as u64),
7110 });
7111 }
7112 }
7113 5u32 => {
7114 if tag.wire_type() != ::buffa::encoding::WireType::Varint {
7115 return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
7116 field_number: 5u32,
7117 expected: 0u8,
7118 actual: tag.wire_type() as u8,
7119 });
7120 }
7121 let __raw = ::buffa::types::decode_int32(buf)?;
7122 if let ::core::option::Option::Some(__v) = ::buffa::Enumeration::from_i32(
7123 __raw,
7124 ) {
7125 self.message_encoding = ::core::option::Option::Some(__v);
7126 } else {
7127 self.__buffa_unknown_fields
7128 .push(::buffa::UnknownField {
7129 number: 5u32,
7130 data: ::buffa::UnknownFieldData::Varint(__raw as u64),
7131 });
7132 }
7133 }
7134 6u32 => {
7135 if tag.wire_type() != ::buffa::encoding::WireType::Varint {
7136 return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
7137 field_number: 6u32,
7138 expected: 0u8,
7139 actual: tag.wire_type() as u8,
7140 });
7141 }
7142 let __raw = ::buffa::types::decode_int32(buf)?;
7143 if let ::core::option::Option::Some(__v) = ::buffa::Enumeration::from_i32(
7144 __raw,
7145 ) {
7146 self.json_format = ::core::option::Option::Some(__v);
7147 } else {
7148 self.__buffa_unknown_fields
7149 .push(::buffa::UnknownField {
7150 number: 6u32,
7151 data: ::buffa::UnknownFieldData::Varint(__raw as u64),
7152 });
7153 }
7154 }
7155 7u32 => {
7156 if tag.wire_type() != ::buffa::encoding::WireType::Varint {
7157 return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
7158 field_number: 7u32,
7159 expected: 0u8,
7160 actual: tag.wire_type() as u8,
7161 });
7162 }
7163 let __raw = ::buffa::types::decode_int32(buf)?;
7164 if let ::core::option::Option::Some(__v) = ::buffa::Enumeration::from_i32(
7165 __raw,
7166 ) {
7167 self.enforce_naming_style = ::core::option::Option::Some(__v);
7168 } else {
7169 self.__buffa_unknown_fields
7170 .push(::buffa::UnknownField {
7171 number: 7u32,
7172 data: ::buffa::UnknownFieldData::Varint(__raw as u64),
7173 });
7174 }
7175 }
7176 8u32 => {
7177 if tag.wire_type() != ::buffa::encoding::WireType::Varint {
7178 return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
7179 field_number: 8u32,
7180 expected: 0u8,
7181 actual: tag.wire_type() as u8,
7182 });
7183 }
7184 let __raw = ::buffa::types::decode_int32(buf)?;
7185 if let ::core::option::Option::Some(__v) = ::buffa::Enumeration::from_i32(
7186 __raw,
7187 ) {
7188 self.default_symbol_visibility = ::core::option::Option::Some(__v);
7189 } else {
7190 self.__buffa_unknown_fields
7191 .push(::buffa::UnknownField {
7192 number: 8u32,
7193 data: ::buffa::UnknownFieldData::Varint(__raw as u64),
7194 });
7195 }
7196 }
7197 _ => {
7198 self.__buffa_unknown_fields
7199 .push(::buffa::encoding::decode_unknown_field(tag, buf, depth)?);
7200 }
7201 }
7202 ::core::result::Result::Ok(())
7203 }
7204 fn cached_size(&self) -> u32 {
7205 self.__buffa_cached_size.get()
7206 }
7207 fn clear(&mut self) {
7208 self.field_presence = ::core::option::Option::None;
7209 self.enum_type = ::core::option::Option::None;
7210 self.repeated_field_encoding = ::core::option::Option::None;
7211 self.utf8_validation = ::core::option::Option::None;
7212 self.message_encoding = ::core::option::Option::None;
7213 self.json_format = ::core::option::Option::None;
7214 self.enforce_naming_style = ::core::option::Option::None;
7215 self.default_symbol_visibility = ::core::option::Option::None;
7216 self.__buffa_unknown_fields.clear();
7217 self.__buffa_cached_size.set(0);
7218 }
7219}
7220pub mod feature_set {
7221 #[allow(unused_imports)]
7222 use super::*;
7223 #[derive(Clone, Copy, PartialEq, Eq, Hash, Debug)]
7224 #[repr(i32)]
7225 pub enum FieldPresence {
7226 FIELD_PRESENCE_UNKNOWN = 0i32,
7227 EXPLICIT = 1i32,
7228 IMPLICIT = 2i32,
7229 LEGACY_REQUIRED = 3i32,
7230 }
7231 impl ::core::default::Default for FieldPresence {
7232 fn default() -> Self {
7233 Self::FIELD_PRESENCE_UNKNOWN
7234 }
7235 }
7236 impl ::buffa::Enumeration for FieldPresence {
7237 fn from_i32(value: i32) -> ::core::option::Option<Self> {
7238 match value {
7239 0i32 => ::core::option::Option::Some(Self::FIELD_PRESENCE_UNKNOWN),
7240 1i32 => ::core::option::Option::Some(Self::EXPLICIT),
7241 2i32 => ::core::option::Option::Some(Self::IMPLICIT),
7242 3i32 => ::core::option::Option::Some(Self::LEGACY_REQUIRED),
7243 _ => ::core::option::Option::None,
7244 }
7245 }
7246 fn to_i32(&self) -> i32 {
7247 *self as i32
7248 }
7249 fn proto_name(&self) -> &'static str {
7250 match self {
7251 Self::FIELD_PRESENCE_UNKNOWN => "FIELD_PRESENCE_UNKNOWN",
7252 Self::EXPLICIT => "EXPLICIT",
7253 Self::IMPLICIT => "IMPLICIT",
7254 Self::LEGACY_REQUIRED => "LEGACY_REQUIRED",
7255 }
7256 }
7257 fn from_proto_name(name: &str) -> ::core::option::Option<Self> {
7258 match name {
7259 "FIELD_PRESENCE_UNKNOWN" => {
7260 ::core::option::Option::Some(Self::FIELD_PRESENCE_UNKNOWN)
7261 }
7262 "EXPLICIT" => ::core::option::Option::Some(Self::EXPLICIT),
7263 "IMPLICIT" => ::core::option::Option::Some(Self::IMPLICIT),
7264 "LEGACY_REQUIRED" => ::core::option::Option::Some(Self::LEGACY_REQUIRED),
7265 _ => ::core::option::Option::None,
7266 }
7267 }
7268 }
7269 #[derive(Clone, Copy, PartialEq, Eq, Hash, Debug)]
7270 #[repr(i32)]
7271 pub enum EnumType {
7272 ENUM_TYPE_UNKNOWN = 0i32,
7273 OPEN = 1i32,
7274 CLOSED = 2i32,
7275 }
7276 impl ::core::default::Default for EnumType {
7277 fn default() -> Self {
7278 Self::ENUM_TYPE_UNKNOWN
7279 }
7280 }
7281 impl ::buffa::Enumeration for EnumType {
7282 fn from_i32(value: i32) -> ::core::option::Option<Self> {
7283 match value {
7284 0i32 => ::core::option::Option::Some(Self::ENUM_TYPE_UNKNOWN),
7285 1i32 => ::core::option::Option::Some(Self::OPEN),
7286 2i32 => ::core::option::Option::Some(Self::CLOSED),
7287 _ => ::core::option::Option::None,
7288 }
7289 }
7290 fn to_i32(&self) -> i32 {
7291 *self as i32
7292 }
7293 fn proto_name(&self) -> &'static str {
7294 match self {
7295 Self::ENUM_TYPE_UNKNOWN => "ENUM_TYPE_UNKNOWN",
7296 Self::OPEN => "OPEN",
7297 Self::CLOSED => "CLOSED",
7298 }
7299 }
7300 fn from_proto_name(name: &str) -> ::core::option::Option<Self> {
7301 match name {
7302 "ENUM_TYPE_UNKNOWN" => {
7303 ::core::option::Option::Some(Self::ENUM_TYPE_UNKNOWN)
7304 }
7305 "OPEN" => ::core::option::Option::Some(Self::OPEN),
7306 "CLOSED" => ::core::option::Option::Some(Self::CLOSED),
7307 _ => ::core::option::Option::None,
7308 }
7309 }
7310 }
7311 #[derive(Clone, Copy, PartialEq, Eq, Hash, Debug)]
7312 #[repr(i32)]
7313 pub enum RepeatedFieldEncoding {
7314 REPEATED_FIELD_ENCODING_UNKNOWN = 0i32,
7315 PACKED = 1i32,
7316 EXPANDED = 2i32,
7317 }
7318 impl ::core::default::Default for RepeatedFieldEncoding {
7319 fn default() -> Self {
7320 Self::REPEATED_FIELD_ENCODING_UNKNOWN
7321 }
7322 }
7323 impl ::buffa::Enumeration for RepeatedFieldEncoding {
7324 fn from_i32(value: i32) -> ::core::option::Option<Self> {
7325 match value {
7326 0i32 => {
7327 ::core::option::Option::Some(Self::REPEATED_FIELD_ENCODING_UNKNOWN)
7328 }
7329 1i32 => ::core::option::Option::Some(Self::PACKED),
7330 2i32 => ::core::option::Option::Some(Self::EXPANDED),
7331 _ => ::core::option::Option::None,
7332 }
7333 }
7334 fn to_i32(&self) -> i32 {
7335 *self as i32
7336 }
7337 fn proto_name(&self) -> &'static str {
7338 match self {
7339 Self::REPEATED_FIELD_ENCODING_UNKNOWN => {
7340 "REPEATED_FIELD_ENCODING_UNKNOWN"
7341 }
7342 Self::PACKED => "PACKED",
7343 Self::EXPANDED => "EXPANDED",
7344 }
7345 }
7346 fn from_proto_name(name: &str) -> ::core::option::Option<Self> {
7347 match name {
7348 "REPEATED_FIELD_ENCODING_UNKNOWN" => {
7349 ::core::option::Option::Some(Self::REPEATED_FIELD_ENCODING_UNKNOWN)
7350 }
7351 "PACKED" => ::core::option::Option::Some(Self::PACKED),
7352 "EXPANDED" => ::core::option::Option::Some(Self::EXPANDED),
7353 _ => ::core::option::Option::None,
7354 }
7355 }
7356 }
7357 #[derive(Clone, Copy, PartialEq, Eq, Hash, Debug)]
7358 #[repr(i32)]
7359 pub enum Utf8Validation {
7360 UTF8_VALIDATION_UNKNOWN = 0i32,
7361 VERIFY = 2i32,
7362 NONE = 3i32,
7363 }
7364 impl ::core::default::Default for Utf8Validation {
7365 fn default() -> Self {
7366 Self::UTF8_VALIDATION_UNKNOWN
7367 }
7368 }
7369 impl ::buffa::Enumeration for Utf8Validation {
7370 fn from_i32(value: i32) -> ::core::option::Option<Self> {
7371 match value {
7372 0i32 => ::core::option::Option::Some(Self::UTF8_VALIDATION_UNKNOWN),
7373 2i32 => ::core::option::Option::Some(Self::VERIFY),
7374 3i32 => ::core::option::Option::Some(Self::NONE),
7375 _ => ::core::option::Option::None,
7376 }
7377 }
7378 fn to_i32(&self) -> i32 {
7379 *self as i32
7380 }
7381 fn proto_name(&self) -> &'static str {
7382 match self {
7383 Self::UTF8_VALIDATION_UNKNOWN => "UTF8_VALIDATION_UNKNOWN",
7384 Self::VERIFY => "VERIFY",
7385 Self::NONE => "NONE",
7386 }
7387 }
7388 fn from_proto_name(name: &str) -> ::core::option::Option<Self> {
7389 match name {
7390 "UTF8_VALIDATION_UNKNOWN" => {
7391 ::core::option::Option::Some(Self::UTF8_VALIDATION_UNKNOWN)
7392 }
7393 "VERIFY" => ::core::option::Option::Some(Self::VERIFY),
7394 "NONE" => ::core::option::Option::Some(Self::NONE),
7395 _ => ::core::option::Option::None,
7396 }
7397 }
7398 }
7399 #[derive(Clone, Copy, PartialEq, Eq, Hash, Debug)]
7400 #[repr(i32)]
7401 pub enum MessageEncoding {
7402 MESSAGE_ENCODING_UNKNOWN = 0i32,
7403 LENGTH_PREFIXED = 1i32,
7404 DELIMITED = 2i32,
7405 }
7406 impl ::core::default::Default for MessageEncoding {
7407 fn default() -> Self {
7408 Self::MESSAGE_ENCODING_UNKNOWN
7409 }
7410 }
7411 impl ::buffa::Enumeration for MessageEncoding {
7412 fn from_i32(value: i32) -> ::core::option::Option<Self> {
7413 match value {
7414 0i32 => ::core::option::Option::Some(Self::MESSAGE_ENCODING_UNKNOWN),
7415 1i32 => ::core::option::Option::Some(Self::LENGTH_PREFIXED),
7416 2i32 => ::core::option::Option::Some(Self::DELIMITED),
7417 _ => ::core::option::Option::None,
7418 }
7419 }
7420 fn to_i32(&self) -> i32 {
7421 *self as i32
7422 }
7423 fn proto_name(&self) -> &'static str {
7424 match self {
7425 Self::MESSAGE_ENCODING_UNKNOWN => "MESSAGE_ENCODING_UNKNOWN",
7426 Self::LENGTH_PREFIXED => "LENGTH_PREFIXED",
7427 Self::DELIMITED => "DELIMITED",
7428 }
7429 }
7430 fn from_proto_name(name: &str) -> ::core::option::Option<Self> {
7431 match name {
7432 "MESSAGE_ENCODING_UNKNOWN" => {
7433 ::core::option::Option::Some(Self::MESSAGE_ENCODING_UNKNOWN)
7434 }
7435 "LENGTH_PREFIXED" => ::core::option::Option::Some(Self::LENGTH_PREFIXED),
7436 "DELIMITED" => ::core::option::Option::Some(Self::DELIMITED),
7437 _ => ::core::option::Option::None,
7438 }
7439 }
7440 }
7441 #[derive(Clone, Copy, PartialEq, Eq, Hash, Debug)]
7442 #[repr(i32)]
7443 pub enum JsonFormat {
7444 JSON_FORMAT_UNKNOWN = 0i32,
7445 ALLOW = 1i32,
7446 LEGACY_BEST_EFFORT = 2i32,
7447 }
7448 impl ::core::default::Default for JsonFormat {
7449 fn default() -> Self {
7450 Self::JSON_FORMAT_UNKNOWN
7451 }
7452 }
7453 impl ::buffa::Enumeration for JsonFormat {
7454 fn from_i32(value: i32) -> ::core::option::Option<Self> {
7455 match value {
7456 0i32 => ::core::option::Option::Some(Self::JSON_FORMAT_UNKNOWN),
7457 1i32 => ::core::option::Option::Some(Self::ALLOW),
7458 2i32 => ::core::option::Option::Some(Self::LEGACY_BEST_EFFORT),
7459 _ => ::core::option::Option::None,
7460 }
7461 }
7462 fn to_i32(&self) -> i32 {
7463 *self as i32
7464 }
7465 fn proto_name(&self) -> &'static str {
7466 match self {
7467 Self::JSON_FORMAT_UNKNOWN => "JSON_FORMAT_UNKNOWN",
7468 Self::ALLOW => "ALLOW",
7469 Self::LEGACY_BEST_EFFORT => "LEGACY_BEST_EFFORT",
7470 }
7471 }
7472 fn from_proto_name(name: &str) -> ::core::option::Option<Self> {
7473 match name {
7474 "JSON_FORMAT_UNKNOWN" => {
7475 ::core::option::Option::Some(Self::JSON_FORMAT_UNKNOWN)
7476 }
7477 "ALLOW" => ::core::option::Option::Some(Self::ALLOW),
7478 "LEGACY_BEST_EFFORT" => {
7479 ::core::option::Option::Some(Self::LEGACY_BEST_EFFORT)
7480 }
7481 _ => ::core::option::Option::None,
7482 }
7483 }
7484 }
7485 #[derive(Clone, Copy, PartialEq, Eq, Hash, Debug)]
7486 #[repr(i32)]
7487 pub enum EnforceNamingStyle {
7488 ENFORCE_NAMING_STYLE_UNKNOWN = 0i32,
7489 STYLE2024 = 1i32,
7490 STYLE_LEGACY = 2i32,
7491 }
7492 impl ::core::default::Default for EnforceNamingStyle {
7493 fn default() -> Self {
7494 Self::ENFORCE_NAMING_STYLE_UNKNOWN
7495 }
7496 }
7497 impl ::buffa::Enumeration for EnforceNamingStyle {
7498 fn from_i32(value: i32) -> ::core::option::Option<Self> {
7499 match value {
7500 0i32 => ::core::option::Option::Some(Self::ENFORCE_NAMING_STYLE_UNKNOWN),
7501 1i32 => ::core::option::Option::Some(Self::STYLE2024),
7502 2i32 => ::core::option::Option::Some(Self::STYLE_LEGACY),
7503 _ => ::core::option::Option::None,
7504 }
7505 }
7506 fn to_i32(&self) -> i32 {
7507 *self as i32
7508 }
7509 fn proto_name(&self) -> &'static str {
7510 match self {
7511 Self::ENFORCE_NAMING_STYLE_UNKNOWN => "ENFORCE_NAMING_STYLE_UNKNOWN",
7512 Self::STYLE2024 => "STYLE2024",
7513 Self::STYLE_LEGACY => "STYLE_LEGACY",
7514 }
7515 }
7516 fn from_proto_name(name: &str) -> ::core::option::Option<Self> {
7517 match name {
7518 "ENFORCE_NAMING_STYLE_UNKNOWN" => {
7519 ::core::option::Option::Some(Self::ENFORCE_NAMING_STYLE_UNKNOWN)
7520 }
7521 "STYLE2024" => ::core::option::Option::Some(Self::STYLE2024),
7522 "STYLE_LEGACY" => ::core::option::Option::Some(Self::STYLE_LEGACY),
7523 _ => ::core::option::Option::None,
7524 }
7525 }
7526 }
7527 #[derive(Clone, PartialEq, Default)]
7528 pub struct VisibilityFeature {
7529 #[doc(hidden)]
7530 pub __buffa_unknown_fields: ::buffa::UnknownFields,
7531 #[doc(hidden)]
7532 pub __buffa_cached_size: ::buffa::__private::CachedSize,
7533 }
7534 impl ::core::fmt::Debug for VisibilityFeature {
7535 fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
7536 f.debug_struct("VisibilityFeature").finish()
7537 }
7538 }
7539 impl VisibilityFeature {
7540 pub const TYPE_URL: &'static str = "type.googleapis.com/google.protobuf.FeatureSet.VisibilityFeature";
7545 }
7546 unsafe impl ::buffa::DefaultInstance for VisibilityFeature {
7547 fn default_instance() -> &'static Self {
7548 static VALUE: ::buffa::__private::OnceBox<VisibilityFeature> = ::buffa::__private::OnceBox::new();
7549 VALUE
7550 .get_or_init(|| ::buffa::alloc::boxed::Box::new(
7551 VisibilityFeature::default(),
7552 ))
7553 }
7554 }
7555 impl ::buffa::Message for VisibilityFeature {
7556 fn compute_size(&self) -> u32 {
7562 #[allow(unused_imports)]
7563 use ::buffa::Enumeration as _;
7564 let mut size = 0u32;
7565 size += self.__buffa_unknown_fields.encoded_len() as u32;
7566 self.__buffa_cached_size.set(size);
7567 size
7568 }
7569 fn write_to(&self, buf: &mut impl ::buffa::bytes::BufMut) {
7570 #[allow(unused_imports)]
7571 use ::buffa::Enumeration as _;
7572 self.__buffa_unknown_fields.write_to(buf);
7573 }
7574 fn merge_field(
7575 &mut self,
7576 tag: ::buffa::encoding::Tag,
7577 buf: &mut impl ::buffa::bytes::Buf,
7578 depth: u32,
7579 ) -> ::core::result::Result<(), ::buffa::DecodeError> {
7580 #[allow(unused_imports)]
7581 use ::buffa::bytes::Buf as _;
7582 #[allow(unused_imports)]
7583 use ::buffa::Enumeration as _;
7584 match tag.field_number() {
7585 _ => {
7586 self.__buffa_unknown_fields
7587 .push(::buffa::encoding::decode_unknown_field(tag, buf, depth)?);
7588 }
7589 }
7590 ::core::result::Result::Ok(())
7591 }
7592 fn cached_size(&self) -> u32 {
7593 self.__buffa_cached_size.get()
7594 }
7595 fn clear(&mut self) {
7596 self.__buffa_unknown_fields.clear();
7597 self.__buffa_cached_size.set(0);
7598 }
7599 }
7600 pub mod visibility_feature {
7601 #[allow(unused_imports)]
7602 use super::*;
7603 #[derive(Clone, Copy, PartialEq, Eq, Hash, Debug)]
7604 #[repr(i32)]
7605 pub enum DefaultSymbolVisibility {
7606 DEFAULT_SYMBOL_VISIBILITY_UNKNOWN = 0i32,
7607 EXPORT_ALL = 1i32,
7608 EXPORT_TOP_LEVEL = 2i32,
7609 LOCAL_ALL = 3i32,
7610 STRICT = 4i32,
7611 }
7612 impl ::core::default::Default for DefaultSymbolVisibility {
7613 fn default() -> Self {
7614 Self::DEFAULT_SYMBOL_VISIBILITY_UNKNOWN
7615 }
7616 }
7617 impl ::buffa::Enumeration for DefaultSymbolVisibility {
7618 fn from_i32(value: i32) -> ::core::option::Option<Self> {
7619 match value {
7620 0i32 => {
7621 ::core::option::Option::Some(
7622 Self::DEFAULT_SYMBOL_VISIBILITY_UNKNOWN,
7623 )
7624 }
7625 1i32 => ::core::option::Option::Some(Self::EXPORT_ALL),
7626 2i32 => ::core::option::Option::Some(Self::EXPORT_TOP_LEVEL),
7627 3i32 => ::core::option::Option::Some(Self::LOCAL_ALL),
7628 4i32 => ::core::option::Option::Some(Self::STRICT),
7629 _ => ::core::option::Option::None,
7630 }
7631 }
7632 fn to_i32(&self) -> i32 {
7633 *self as i32
7634 }
7635 fn proto_name(&self) -> &'static str {
7636 match self {
7637 Self::DEFAULT_SYMBOL_VISIBILITY_UNKNOWN => {
7638 "DEFAULT_SYMBOL_VISIBILITY_UNKNOWN"
7639 }
7640 Self::EXPORT_ALL => "EXPORT_ALL",
7641 Self::EXPORT_TOP_LEVEL => "EXPORT_TOP_LEVEL",
7642 Self::LOCAL_ALL => "LOCAL_ALL",
7643 Self::STRICT => "STRICT",
7644 }
7645 }
7646 fn from_proto_name(name: &str) -> ::core::option::Option<Self> {
7647 match name {
7648 "DEFAULT_SYMBOL_VISIBILITY_UNKNOWN" => {
7649 ::core::option::Option::Some(
7650 Self::DEFAULT_SYMBOL_VISIBILITY_UNKNOWN,
7651 )
7652 }
7653 "EXPORT_ALL" => ::core::option::Option::Some(Self::EXPORT_ALL),
7654 "EXPORT_TOP_LEVEL" => {
7655 ::core::option::Option::Some(Self::EXPORT_TOP_LEVEL)
7656 }
7657 "LOCAL_ALL" => ::core::option::Option::Some(Self::LOCAL_ALL),
7658 "STRICT" => ::core::option::Option::Some(Self::STRICT),
7659 _ => ::core::option::Option::None,
7660 }
7661 }
7662 }
7663 }
7664}
7665#[derive(Clone, PartialEq, Default)]
7666pub struct FeatureSetDefaults {
7667 pub defaults: ::buffa::alloc::vec::Vec<
7669 feature_set_defaults::FeatureSetEditionDefault,
7670 >,
7671 pub minimum_edition: Option<Edition>,
7673 pub maximum_edition: Option<Edition>,
7675 #[doc(hidden)]
7676 pub __buffa_unknown_fields: ::buffa::UnknownFields,
7677 #[doc(hidden)]
7678 pub __buffa_cached_size: ::buffa::__private::CachedSize,
7679}
7680impl ::core::fmt::Debug for FeatureSetDefaults {
7681 fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
7682 f.debug_struct("FeatureSetDefaults")
7683 .field("defaults", &self.defaults)
7684 .field("minimum_edition", &self.minimum_edition)
7685 .field("maximum_edition", &self.maximum_edition)
7686 .finish()
7687 }
7688}
7689impl FeatureSetDefaults {
7690 pub const TYPE_URL: &'static str = "type.googleapis.com/google.protobuf.FeatureSetDefaults";
7695}
7696unsafe impl ::buffa::DefaultInstance for FeatureSetDefaults {
7697 fn default_instance() -> &'static Self {
7698 static VALUE: ::buffa::__private::OnceBox<FeatureSetDefaults> = ::buffa::__private::OnceBox::new();
7699 VALUE
7700 .get_or_init(|| ::buffa::alloc::boxed::Box::new(
7701 FeatureSetDefaults::default(),
7702 ))
7703 }
7704}
7705impl ::buffa::Message for FeatureSetDefaults {
7706 fn compute_size(&self) -> u32 {
7712 #[allow(unused_imports)]
7713 use ::buffa::Enumeration as _;
7714 let mut size = 0u32;
7715 if let Some(ref v) = self.minimum_edition {
7716 size += 1u32 + ::buffa::types::int32_encoded_len(v.to_i32()) as u32;
7717 }
7718 if let Some(ref v) = self.maximum_edition {
7719 size += 1u32 + ::buffa::types::int32_encoded_len(v.to_i32()) as u32;
7720 }
7721 for v in &self.defaults {
7722 let inner_size = v.compute_size();
7723 size
7724 += 1u32 + ::buffa::encoding::varint_len(inner_size as u64) as u32
7725 + inner_size;
7726 }
7727 size += self.__buffa_unknown_fields.encoded_len() as u32;
7728 self.__buffa_cached_size.set(size);
7729 size
7730 }
7731 fn write_to(&self, buf: &mut impl ::buffa::bytes::BufMut) {
7732 #[allow(unused_imports)]
7733 use ::buffa::Enumeration as _;
7734 if let Some(ref v) = self.minimum_edition {
7735 ::buffa::encoding::Tag::new(4u32, ::buffa::encoding::WireType::Varint)
7736 .encode(buf);
7737 ::buffa::types::encode_int32(v.to_i32(), buf);
7738 }
7739 if let Some(ref v) = self.maximum_edition {
7740 ::buffa::encoding::Tag::new(5u32, ::buffa::encoding::WireType::Varint)
7741 .encode(buf);
7742 ::buffa::types::encode_int32(v.to_i32(), buf);
7743 }
7744 for v in &self.defaults {
7745 ::buffa::encoding::Tag::new(
7746 1u32,
7747 ::buffa::encoding::WireType::LengthDelimited,
7748 )
7749 .encode(buf);
7750 ::buffa::encoding::encode_varint(v.cached_size() as u64, buf);
7751 v.write_to(buf);
7752 }
7753 self.__buffa_unknown_fields.write_to(buf);
7754 }
7755 fn merge_field(
7756 &mut self,
7757 tag: ::buffa::encoding::Tag,
7758 buf: &mut impl ::buffa::bytes::Buf,
7759 depth: u32,
7760 ) -> ::core::result::Result<(), ::buffa::DecodeError> {
7761 #[allow(unused_imports)]
7762 use ::buffa::bytes::Buf as _;
7763 #[allow(unused_imports)]
7764 use ::buffa::Enumeration as _;
7765 match tag.field_number() {
7766 4u32 => {
7767 if tag.wire_type() != ::buffa::encoding::WireType::Varint {
7768 return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
7769 field_number: 4u32,
7770 expected: 0u8,
7771 actual: tag.wire_type() as u8,
7772 });
7773 }
7774 let __raw = ::buffa::types::decode_int32(buf)?;
7775 if let ::core::option::Option::Some(__v) = ::buffa::Enumeration::from_i32(
7776 __raw,
7777 ) {
7778 self.minimum_edition = ::core::option::Option::Some(__v);
7779 } else {
7780 self.__buffa_unknown_fields
7781 .push(::buffa::UnknownField {
7782 number: 4u32,
7783 data: ::buffa::UnknownFieldData::Varint(__raw as u64),
7784 });
7785 }
7786 }
7787 5u32 => {
7788 if tag.wire_type() != ::buffa::encoding::WireType::Varint {
7789 return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
7790 field_number: 5u32,
7791 expected: 0u8,
7792 actual: tag.wire_type() as u8,
7793 });
7794 }
7795 let __raw = ::buffa::types::decode_int32(buf)?;
7796 if let ::core::option::Option::Some(__v) = ::buffa::Enumeration::from_i32(
7797 __raw,
7798 ) {
7799 self.maximum_edition = ::core::option::Option::Some(__v);
7800 } else {
7801 self.__buffa_unknown_fields
7802 .push(::buffa::UnknownField {
7803 number: 5u32,
7804 data: ::buffa::UnknownFieldData::Varint(__raw as u64),
7805 });
7806 }
7807 }
7808 1u32 => {
7809 if tag.wire_type() != ::buffa::encoding::WireType::LengthDelimited {
7810 return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
7811 field_number: 1u32,
7812 expected: 2u8,
7813 actual: tag.wire_type() as u8,
7814 });
7815 }
7816 let mut elem = ::core::default::Default::default();
7817 ::buffa::Message::merge_length_delimited(&mut elem, buf, depth)?;
7818 self.defaults.push(elem);
7819 }
7820 _ => {
7821 self.__buffa_unknown_fields
7822 .push(::buffa::encoding::decode_unknown_field(tag, buf, depth)?);
7823 }
7824 }
7825 ::core::result::Result::Ok(())
7826 }
7827 fn cached_size(&self) -> u32 {
7828 self.__buffa_cached_size.get()
7829 }
7830 fn clear(&mut self) {
7831 self.minimum_edition = ::core::option::Option::None;
7832 self.maximum_edition = ::core::option::Option::None;
7833 self.defaults.clear();
7834 self.__buffa_unknown_fields.clear();
7835 self.__buffa_cached_size.set(0);
7836 }
7837}
7838pub mod feature_set_defaults {
7839 #[allow(unused_imports)]
7840 use super::*;
7841 #[derive(Clone, PartialEq, Default)]
7842 pub struct FeatureSetEditionDefault {
7843 pub edition: Option<Edition>,
7845 pub overridable_features: ::buffa::MessageField<FeatureSet>,
7847 pub fixed_features: ::buffa::MessageField<FeatureSet>,
7849 #[doc(hidden)]
7850 pub __buffa_unknown_fields: ::buffa::UnknownFields,
7851 #[doc(hidden)]
7852 pub __buffa_cached_size: ::buffa::__private::CachedSize,
7853 }
7854 impl ::core::fmt::Debug for FeatureSetEditionDefault {
7855 fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
7856 f.debug_struct("FeatureSetEditionDefault")
7857 .field("edition", &self.edition)
7858 .field("overridable_features", &self.overridable_features)
7859 .field("fixed_features", &self.fixed_features)
7860 .finish()
7861 }
7862 }
7863 impl FeatureSetEditionDefault {
7864 pub const TYPE_URL: &'static str = "type.googleapis.com/google.protobuf.FeatureSetDefaults.FeatureSetEditionDefault";
7869 }
7870 unsafe impl ::buffa::DefaultInstance for FeatureSetEditionDefault {
7871 fn default_instance() -> &'static Self {
7872 static VALUE: ::buffa::__private::OnceBox<FeatureSetEditionDefault> = ::buffa::__private::OnceBox::new();
7873 VALUE
7874 .get_or_init(|| ::buffa::alloc::boxed::Box::new(
7875 FeatureSetEditionDefault::default(),
7876 ))
7877 }
7878 }
7879 impl ::buffa::Message for FeatureSetEditionDefault {
7880 fn compute_size(&self) -> u32 {
7886 #[allow(unused_imports)]
7887 use ::buffa::Enumeration as _;
7888 let mut size = 0u32;
7889 if let Some(ref v) = self.edition {
7890 size += 1u32 + ::buffa::types::int32_encoded_len(v.to_i32()) as u32;
7891 }
7892 if self.overridable_features.is_set() {
7893 let inner_size = self.overridable_features.compute_size();
7894 size
7895 += 1u32 + ::buffa::encoding::varint_len(inner_size as u64) as u32
7896 + inner_size;
7897 }
7898 if self.fixed_features.is_set() {
7899 let inner_size = self.fixed_features.compute_size();
7900 size
7901 += 1u32 + ::buffa::encoding::varint_len(inner_size as u64) as u32
7902 + inner_size;
7903 }
7904 size += self.__buffa_unknown_fields.encoded_len() as u32;
7905 self.__buffa_cached_size.set(size);
7906 size
7907 }
7908 fn write_to(&self, buf: &mut impl ::buffa::bytes::BufMut) {
7909 #[allow(unused_imports)]
7910 use ::buffa::Enumeration as _;
7911 if let Some(ref v) = self.edition {
7912 ::buffa::encoding::Tag::new(3u32, ::buffa::encoding::WireType::Varint)
7913 .encode(buf);
7914 ::buffa::types::encode_int32(v.to_i32(), buf);
7915 }
7916 if self.overridable_features.is_set() {
7917 ::buffa::encoding::Tag::new(
7918 4u32,
7919 ::buffa::encoding::WireType::LengthDelimited,
7920 )
7921 .encode(buf);
7922 ::buffa::encoding::encode_varint(
7923 self.overridable_features.cached_size() as u64,
7924 buf,
7925 );
7926 self.overridable_features.write_to(buf);
7927 }
7928 if self.fixed_features.is_set() {
7929 ::buffa::encoding::Tag::new(
7930 5u32,
7931 ::buffa::encoding::WireType::LengthDelimited,
7932 )
7933 .encode(buf);
7934 ::buffa::encoding::encode_varint(
7935 self.fixed_features.cached_size() as u64,
7936 buf,
7937 );
7938 self.fixed_features.write_to(buf);
7939 }
7940 self.__buffa_unknown_fields.write_to(buf);
7941 }
7942 fn merge_field(
7943 &mut self,
7944 tag: ::buffa::encoding::Tag,
7945 buf: &mut impl ::buffa::bytes::Buf,
7946 depth: u32,
7947 ) -> ::core::result::Result<(), ::buffa::DecodeError> {
7948 #[allow(unused_imports)]
7949 use ::buffa::bytes::Buf as _;
7950 #[allow(unused_imports)]
7951 use ::buffa::Enumeration as _;
7952 match tag.field_number() {
7953 3u32 => {
7954 if tag.wire_type() != ::buffa::encoding::WireType::Varint {
7955 return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
7956 field_number: 3u32,
7957 expected: 0u8,
7958 actual: tag.wire_type() as u8,
7959 });
7960 }
7961 let __raw = ::buffa::types::decode_int32(buf)?;
7962 if let ::core::option::Option::Some(__v) = ::buffa::Enumeration::from_i32(
7963 __raw,
7964 ) {
7965 self.edition = ::core::option::Option::Some(__v);
7966 } else {
7967 self.__buffa_unknown_fields
7968 .push(::buffa::UnknownField {
7969 number: 3u32,
7970 data: ::buffa::UnknownFieldData::Varint(__raw as u64),
7971 });
7972 }
7973 }
7974 4u32 => {
7975 if tag.wire_type() != ::buffa::encoding::WireType::LengthDelimited {
7976 return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
7977 field_number: 4u32,
7978 expected: 2u8,
7979 actual: tag.wire_type() as u8,
7980 });
7981 }
7982 ::buffa::Message::merge_length_delimited(
7983 self.overridable_features.get_or_insert_default(),
7984 buf,
7985 depth,
7986 )?;
7987 }
7988 5u32 => {
7989 if tag.wire_type() != ::buffa::encoding::WireType::LengthDelimited {
7990 return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
7991 field_number: 5u32,
7992 expected: 2u8,
7993 actual: tag.wire_type() as u8,
7994 });
7995 }
7996 ::buffa::Message::merge_length_delimited(
7997 self.fixed_features.get_or_insert_default(),
7998 buf,
7999 depth,
8000 )?;
8001 }
8002 _ => {
8003 self.__buffa_unknown_fields
8004 .push(::buffa::encoding::decode_unknown_field(tag, buf, depth)?);
8005 }
8006 }
8007 ::core::result::Result::Ok(())
8008 }
8009 fn cached_size(&self) -> u32 {
8010 self.__buffa_cached_size.get()
8011 }
8012 fn clear(&mut self) {
8013 self.edition = ::core::option::Option::None;
8014 self.overridable_features = ::buffa::MessageField::none();
8015 self.fixed_features = ::buffa::MessageField::none();
8016 self.__buffa_unknown_fields.clear();
8017 self.__buffa_cached_size.set(0);
8018 }
8019 }
8020}
8021#[derive(Clone, PartialEq, Default)]
8022pub struct SourceCodeInfo {
8023 pub location: ::buffa::alloc::vec::Vec<source_code_info::Location>,
8025 #[doc(hidden)]
8026 pub __buffa_unknown_fields: ::buffa::UnknownFields,
8027 #[doc(hidden)]
8028 pub __buffa_cached_size: ::buffa::__private::CachedSize,
8029}
8030impl ::core::fmt::Debug for SourceCodeInfo {
8031 fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
8032 f.debug_struct("SourceCodeInfo").field("location", &self.location).finish()
8033 }
8034}
8035impl SourceCodeInfo {
8036 pub const TYPE_URL: &'static str = "type.googleapis.com/google.protobuf.SourceCodeInfo";
8041}
8042unsafe impl ::buffa::DefaultInstance for SourceCodeInfo {
8043 fn default_instance() -> &'static Self {
8044 static VALUE: ::buffa::__private::OnceBox<SourceCodeInfo> = ::buffa::__private::OnceBox::new();
8045 VALUE.get_or_init(|| ::buffa::alloc::boxed::Box::new(SourceCodeInfo::default()))
8046 }
8047}
8048impl ::buffa::Message for SourceCodeInfo {
8049 fn compute_size(&self) -> u32 {
8055 #[allow(unused_imports)]
8056 use ::buffa::Enumeration as _;
8057 let mut size = 0u32;
8058 for v in &self.location {
8059 let inner_size = v.compute_size();
8060 size
8061 += 1u32 + ::buffa::encoding::varint_len(inner_size as u64) as u32
8062 + inner_size;
8063 }
8064 size += self.__buffa_unknown_fields.encoded_len() as u32;
8065 self.__buffa_cached_size.set(size);
8066 size
8067 }
8068 fn write_to(&self, buf: &mut impl ::buffa::bytes::BufMut) {
8069 #[allow(unused_imports)]
8070 use ::buffa::Enumeration as _;
8071 for v in &self.location {
8072 ::buffa::encoding::Tag::new(
8073 1u32,
8074 ::buffa::encoding::WireType::LengthDelimited,
8075 )
8076 .encode(buf);
8077 ::buffa::encoding::encode_varint(v.cached_size() as u64, buf);
8078 v.write_to(buf);
8079 }
8080 self.__buffa_unknown_fields.write_to(buf);
8081 }
8082 fn merge_field(
8083 &mut self,
8084 tag: ::buffa::encoding::Tag,
8085 buf: &mut impl ::buffa::bytes::Buf,
8086 depth: u32,
8087 ) -> ::core::result::Result<(), ::buffa::DecodeError> {
8088 #[allow(unused_imports)]
8089 use ::buffa::bytes::Buf as _;
8090 #[allow(unused_imports)]
8091 use ::buffa::Enumeration as _;
8092 match tag.field_number() {
8093 1u32 => {
8094 if tag.wire_type() != ::buffa::encoding::WireType::LengthDelimited {
8095 return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
8096 field_number: 1u32,
8097 expected: 2u8,
8098 actual: tag.wire_type() as u8,
8099 });
8100 }
8101 let mut elem = ::core::default::Default::default();
8102 ::buffa::Message::merge_length_delimited(&mut elem, buf, depth)?;
8103 self.location.push(elem);
8104 }
8105 _ => {
8106 self.__buffa_unknown_fields
8107 .push(::buffa::encoding::decode_unknown_field(tag, buf, depth)?);
8108 }
8109 }
8110 ::core::result::Result::Ok(())
8111 }
8112 fn cached_size(&self) -> u32 {
8113 self.__buffa_cached_size.get()
8114 }
8115 fn clear(&mut self) {
8116 self.location.clear();
8117 self.__buffa_unknown_fields.clear();
8118 self.__buffa_cached_size.set(0);
8119 }
8120}
8121pub mod source_code_info {
8122 #[allow(unused_imports)]
8123 use super::*;
8124 #[derive(Clone, PartialEq, Default)]
8125 pub struct Location {
8126 pub path: ::buffa::alloc::vec::Vec<i32>,
8128 pub span: ::buffa::alloc::vec::Vec<i32>,
8130 pub leading_comments: Option<::buffa::alloc::string::String>,
8132 pub trailing_comments: Option<::buffa::alloc::string::String>,
8134 pub leading_detached_comments: ::buffa::alloc::vec::Vec<
8136 ::buffa::alloc::string::String,
8137 >,
8138 #[doc(hidden)]
8139 pub __buffa_unknown_fields: ::buffa::UnknownFields,
8140 #[doc(hidden)]
8141 pub __buffa_cached_size: ::buffa::__private::CachedSize,
8142 }
8143 impl ::core::fmt::Debug for Location {
8144 fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
8145 f.debug_struct("Location")
8146 .field("path", &self.path)
8147 .field("span", &self.span)
8148 .field("leading_comments", &self.leading_comments)
8149 .field("trailing_comments", &self.trailing_comments)
8150 .field("leading_detached_comments", &self.leading_detached_comments)
8151 .finish()
8152 }
8153 }
8154 impl Location {
8155 pub const TYPE_URL: &'static str = "type.googleapis.com/google.protobuf.SourceCodeInfo.Location";
8160 }
8161 unsafe impl ::buffa::DefaultInstance for Location {
8162 fn default_instance() -> &'static Self {
8163 static VALUE: ::buffa::__private::OnceBox<Location> = ::buffa::__private::OnceBox::new();
8164 VALUE.get_or_init(|| ::buffa::alloc::boxed::Box::new(Location::default()))
8165 }
8166 }
8167 impl ::buffa::Message for Location {
8168 fn compute_size(&self) -> u32 {
8174 #[allow(unused_imports)]
8175 use ::buffa::Enumeration as _;
8176 let mut size = 0u32;
8177 if let Some(ref v) = self.leading_comments {
8178 size += 1u32 + ::buffa::types::string_encoded_len(v) as u32;
8179 }
8180 if let Some(ref v) = self.trailing_comments {
8181 size += 1u32 + ::buffa::types::string_encoded_len(v) as u32;
8182 }
8183 if !self.path.is_empty() {
8184 let payload: u32 = self
8185 .path
8186 .iter()
8187 .map(|&v| ::buffa::types::int32_encoded_len(v) as u32)
8188 .sum::<u32>();
8189 size
8190 += 1u32 + ::buffa::encoding::varint_len(payload as u64) as u32
8191 + payload;
8192 }
8193 if !self.span.is_empty() {
8194 let payload: u32 = self
8195 .span
8196 .iter()
8197 .map(|&v| ::buffa::types::int32_encoded_len(v) as u32)
8198 .sum::<u32>();
8199 size
8200 += 1u32 + ::buffa::encoding::varint_len(payload as u64) as u32
8201 + payload;
8202 }
8203 for v in &self.leading_detached_comments {
8204 size += 1u32 + ::buffa::types::string_encoded_len(v) as u32;
8205 }
8206 size += self.__buffa_unknown_fields.encoded_len() as u32;
8207 self.__buffa_cached_size.set(size);
8208 size
8209 }
8210 fn write_to(&self, buf: &mut impl ::buffa::bytes::BufMut) {
8211 #[allow(unused_imports)]
8212 use ::buffa::Enumeration as _;
8213 if let Some(ref v) = self.leading_comments {
8214 ::buffa::encoding::Tag::new(
8215 3u32,
8216 ::buffa::encoding::WireType::LengthDelimited,
8217 )
8218 .encode(buf);
8219 ::buffa::types::encode_string(v, buf);
8220 }
8221 if let Some(ref v) = self.trailing_comments {
8222 ::buffa::encoding::Tag::new(
8223 4u32,
8224 ::buffa::encoding::WireType::LengthDelimited,
8225 )
8226 .encode(buf);
8227 ::buffa::types::encode_string(v, buf);
8228 }
8229 if !self.path.is_empty() {
8230 let payload: u32 = self
8231 .path
8232 .iter()
8233 .map(|&v| ::buffa::types::int32_encoded_len(v) as u32)
8234 .sum::<u32>();
8235 ::buffa::encoding::Tag::new(
8236 1u32,
8237 ::buffa::encoding::WireType::LengthDelimited,
8238 )
8239 .encode(buf);
8240 ::buffa::encoding::encode_varint(payload as u64, buf);
8241 for &v in &self.path {
8242 ::buffa::types::encode_int32(v, buf);
8243 }
8244 }
8245 if !self.span.is_empty() {
8246 let payload: u32 = self
8247 .span
8248 .iter()
8249 .map(|&v| ::buffa::types::int32_encoded_len(v) as u32)
8250 .sum::<u32>();
8251 ::buffa::encoding::Tag::new(
8252 2u32,
8253 ::buffa::encoding::WireType::LengthDelimited,
8254 )
8255 .encode(buf);
8256 ::buffa::encoding::encode_varint(payload as u64, buf);
8257 for &v in &self.span {
8258 ::buffa::types::encode_int32(v, buf);
8259 }
8260 }
8261 for v in &self.leading_detached_comments {
8262 ::buffa::encoding::Tag::new(
8263 6u32,
8264 ::buffa::encoding::WireType::LengthDelimited,
8265 )
8266 .encode(buf);
8267 ::buffa::types::encode_string(v, buf);
8268 }
8269 self.__buffa_unknown_fields.write_to(buf);
8270 }
8271 fn merge_field(
8272 &mut self,
8273 tag: ::buffa::encoding::Tag,
8274 buf: &mut impl ::buffa::bytes::Buf,
8275 depth: u32,
8276 ) -> ::core::result::Result<(), ::buffa::DecodeError> {
8277 #[allow(unused_imports)]
8278 use ::buffa::bytes::Buf as _;
8279 #[allow(unused_imports)]
8280 use ::buffa::Enumeration as _;
8281 match tag.field_number() {
8282 3u32 => {
8283 if tag.wire_type() != ::buffa::encoding::WireType::LengthDelimited {
8284 return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
8285 field_number: 3u32,
8286 expected: 2u8,
8287 actual: tag.wire_type() as u8,
8288 });
8289 }
8290 ::buffa::types::merge_string(
8291 self
8292 .leading_comments
8293 .get_or_insert_with(::buffa::alloc::string::String::new),
8294 buf,
8295 )?;
8296 }
8297 4u32 => {
8298 if tag.wire_type() != ::buffa::encoding::WireType::LengthDelimited {
8299 return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
8300 field_number: 4u32,
8301 expected: 2u8,
8302 actual: tag.wire_type() as u8,
8303 });
8304 }
8305 ::buffa::types::merge_string(
8306 self
8307 .trailing_comments
8308 .get_or_insert_with(::buffa::alloc::string::String::new),
8309 buf,
8310 )?;
8311 }
8312 1u32 => {
8313 if tag.wire_type() == ::buffa::encoding::WireType::LengthDelimited {
8314 let len = ::buffa::encoding::decode_varint(buf)?;
8315 let len = usize::try_from(len)
8316 .map_err(|_| ::buffa::DecodeError::MessageTooLarge)?;
8317 if buf.remaining() < len {
8318 return ::core::result::Result::Err(
8319 ::buffa::DecodeError::UnexpectedEof,
8320 );
8321 }
8322 self.path.reserve(len);
8323 let mut limited = buf.take(len);
8324 while limited.has_remaining() {
8325 self.path.push(::buffa::types::decode_int32(&mut limited)?);
8326 }
8327 let leftover = limited.remaining();
8328 if leftover > 0 {
8329 limited.advance(leftover);
8330 }
8331 } else if tag.wire_type() == ::buffa::encoding::WireType::Varint {
8332 self.path.push(::buffa::types::decode_int32(buf)?);
8333 } else {
8334 return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
8335 field_number: 1u32,
8336 expected: 2u8,
8337 actual: tag.wire_type() as u8,
8338 });
8339 }
8340 }
8341 2u32 => {
8342 if tag.wire_type() == ::buffa::encoding::WireType::LengthDelimited {
8343 let len = ::buffa::encoding::decode_varint(buf)?;
8344 let len = usize::try_from(len)
8345 .map_err(|_| ::buffa::DecodeError::MessageTooLarge)?;
8346 if buf.remaining() < len {
8347 return ::core::result::Result::Err(
8348 ::buffa::DecodeError::UnexpectedEof,
8349 );
8350 }
8351 self.span.reserve(len);
8352 let mut limited = buf.take(len);
8353 while limited.has_remaining() {
8354 self.span.push(::buffa::types::decode_int32(&mut limited)?);
8355 }
8356 let leftover = limited.remaining();
8357 if leftover > 0 {
8358 limited.advance(leftover);
8359 }
8360 } else if tag.wire_type() == ::buffa::encoding::WireType::Varint {
8361 self.span.push(::buffa::types::decode_int32(buf)?);
8362 } else {
8363 return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
8364 field_number: 2u32,
8365 expected: 2u8,
8366 actual: tag.wire_type() as u8,
8367 });
8368 }
8369 }
8370 6u32 => {
8371 if tag.wire_type() != ::buffa::encoding::WireType::LengthDelimited {
8372 return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
8373 field_number: 6u32,
8374 expected: 2u8,
8375 actual: tag.wire_type() as u8,
8376 });
8377 }
8378 self.leading_detached_comments
8379 .push(::buffa::types::decode_string(buf)?);
8380 }
8381 _ => {
8382 self.__buffa_unknown_fields
8383 .push(::buffa::encoding::decode_unknown_field(tag, buf, depth)?);
8384 }
8385 }
8386 ::core::result::Result::Ok(())
8387 }
8388 fn cached_size(&self) -> u32 {
8389 self.__buffa_cached_size.get()
8390 }
8391 fn clear(&mut self) {
8392 self.leading_comments = ::core::option::Option::None;
8393 self.trailing_comments = ::core::option::Option::None;
8394 self.path.clear();
8395 self.span.clear();
8396 self.leading_detached_comments.clear();
8397 self.__buffa_unknown_fields.clear();
8398 self.__buffa_cached_size.set(0);
8399 }
8400 }
8401}
8402#[derive(Clone, PartialEq, Default)]
8403pub struct GeneratedCodeInfo {
8404 pub annotation: ::buffa::alloc::vec::Vec<generated_code_info::Annotation>,
8406 #[doc(hidden)]
8407 pub __buffa_unknown_fields: ::buffa::UnknownFields,
8408 #[doc(hidden)]
8409 pub __buffa_cached_size: ::buffa::__private::CachedSize,
8410}
8411impl ::core::fmt::Debug for GeneratedCodeInfo {
8412 fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
8413 f.debug_struct("GeneratedCodeInfo")
8414 .field("annotation", &self.annotation)
8415 .finish()
8416 }
8417}
8418impl GeneratedCodeInfo {
8419 pub const TYPE_URL: &'static str = "type.googleapis.com/google.protobuf.GeneratedCodeInfo";
8424}
8425unsafe impl ::buffa::DefaultInstance for GeneratedCodeInfo {
8426 fn default_instance() -> &'static Self {
8427 static VALUE: ::buffa::__private::OnceBox<GeneratedCodeInfo> = ::buffa::__private::OnceBox::new();
8428 VALUE
8429 .get_or_init(|| ::buffa::alloc::boxed::Box::new(
8430 GeneratedCodeInfo::default(),
8431 ))
8432 }
8433}
8434impl ::buffa::Message for GeneratedCodeInfo {
8435 fn compute_size(&self) -> u32 {
8441 #[allow(unused_imports)]
8442 use ::buffa::Enumeration as _;
8443 let mut size = 0u32;
8444 for v in &self.annotation {
8445 let inner_size = v.compute_size();
8446 size
8447 += 1u32 + ::buffa::encoding::varint_len(inner_size as u64) as u32
8448 + inner_size;
8449 }
8450 size += self.__buffa_unknown_fields.encoded_len() as u32;
8451 self.__buffa_cached_size.set(size);
8452 size
8453 }
8454 fn write_to(&self, buf: &mut impl ::buffa::bytes::BufMut) {
8455 #[allow(unused_imports)]
8456 use ::buffa::Enumeration as _;
8457 for v in &self.annotation {
8458 ::buffa::encoding::Tag::new(
8459 1u32,
8460 ::buffa::encoding::WireType::LengthDelimited,
8461 )
8462 .encode(buf);
8463 ::buffa::encoding::encode_varint(v.cached_size() as u64, buf);
8464 v.write_to(buf);
8465 }
8466 self.__buffa_unknown_fields.write_to(buf);
8467 }
8468 fn merge_field(
8469 &mut self,
8470 tag: ::buffa::encoding::Tag,
8471 buf: &mut impl ::buffa::bytes::Buf,
8472 depth: u32,
8473 ) -> ::core::result::Result<(), ::buffa::DecodeError> {
8474 #[allow(unused_imports)]
8475 use ::buffa::bytes::Buf as _;
8476 #[allow(unused_imports)]
8477 use ::buffa::Enumeration as _;
8478 match tag.field_number() {
8479 1u32 => {
8480 if tag.wire_type() != ::buffa::encoding::WireType::LengthDelimited {
8481 return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
8482 field_number: 1u32,
8483 expected: 2u8,
8484 actual: tag.wire_type() as u8,
8485 });
8486 }
8487 let mut elem = ::core::default::Default::default();
8488 ::buffa::Message::merge_length_delimited(&mut elem, buf, depth)?;
8489 self.annotation.push(elem);
8490 }
8491 _ => {
8492 self.__buffa_unknown_fields
8493 .push(::buffa::encoding::decode_unknown_field(tag, buf, depth)?);
8494 }
8495 }
8496 ::core::result::Result::Ok(())
8497 }
8498 fn cached_size(&self) -> u32 {
8499 self.__buffa_cached_size.get()
8500 }
8501 fn clear(&mut self) {
8502 self.annotation.clear();
8503 self.__buffa_unknown_fields.clear();
8504 self.__buffa_cached_size.set(0);
8505 }
8506}
8507pub mod generated_code_info {
8508 #[allow(unused_imports)]
8509 use super::*;
8510 #[derive(Clone, PartialEq, Default)]
8511 pub struct Annotation {
8512 pub path: ::buffa::alloc::vec::Vec<i32>,
8514 pub source_file: Option<::buffa::alloc::string::String>,
8516 pub begin: Option<i32>,
8518 pub end: Option<i32>,
8520 pub semantic: Option<generated_code_info::annotation::Semantic>,
8522 #[doc(hidden)]
8523 pub __buffa_unknown_fields: ::buffa::UnknownFields,
8524 #[doc(hidden)]
8525 pub __buffa_cached_size: ::buffa::__private::CachedSize,
8526 }
8527 impl ::core::fmt::Debug for Annotation {
8528 fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
8529 f.debug_struct("Annotation")
8530 .field("path", &self.path)
8531 .field("source_file", &self.source_file)
8532 .field("begin", &self.begin)
8533 .field("end", &self.end)
8534 .field("semantic", &self.semantic)
8535 .finish()
8536 }
8537 }
8538 impl Annotation {
8539 pub const TYPE_URL: &'static str = "type.googleapis.com/google.protobuf.GeneratedCodeInfo.Annotation";
8544 }
8545 unsafe impl ::buffa::DefaultInstance for Annotation {
8546 fn default_instance() -> &'static Self {
8547 static VALUE: ::buffa::__private::OnceBox<Annotation> = ::buffa::__private::OnceBox::new();
8548 VALUE.get_or_init(|| ::buffa::alloc::boxed::Box::new(Annotation::default()))
8549 }
8550 }
8551 impl ::buffa::Message for Annotation {
8552 fn compute_size(&self) -> u32 {
8558 #[allow(unused_imports)]
8559 use ::buffa::Enumeration as _;
8560 let mut size = 0u32;
8561 if let Some(ref v) = self.source_file {
8562 size += 1u32 + ::buffa::types::string_encoded_len(v) as u32;
8563 }
8564 if let Some(v) = self.begin {
8565 size += 1u32 + ::buffa::types::int32_encoded_len(v) as u32;
8566 }
8567 if let Some(v) = self.end {
8568 size += 1u32 + ::buffa::types::int32_encoded_len(v) as u32;
8569 }
8570 if let Some(ref v) = self.semantic {
8571 size += 1u32 + ::buffa::types::int32_encoded_len(v.to_i32()) as u32;
8572 }
8573 if !self.path.is_empty() {
8574 let payload: u32 = self
8575 .path
8576 .iter()
8577 .map(|&v| ::buffa::types::int32_encoded_len(v) as u32)
8578 .sum::<u32>();
8579 size
8580 += 1u32 + ::buffa::encoding::varint_len(payload as u64) as u32
8581 + payload;
8582 }
8583 size += self.__buffa_unknown_fields.encoded_len() as u32;
8584 self.__buffa_cached_size.set(size);
8585 size
8586 }
8587 fn write_to(&self, buf: &mut impl ::buffa::bytes::BufMut) {
8588 #[allow(unused_imports)]
8589 use ::buffa::Enumeration as _;
8590 if let Some(ref v) = self.source_file {
8591 ::buffa::encoding::Tag::new(
8592 2u32,
8593 ::buffa::encoding::WireType::LengthDelimited,
8594 )
8595 .encode(buf);
8596 ::buffa::types::encode_string(v, buf);
8597 }
8598 if let Some(v) = self.begin {
8599 ::buffa::encoding::Tag::new(3u32, ::buffa::encoding::WireType::Varint)
8600 .encode(buf);
8601 ::buffa::types::encode_int32(v, buf);
8602 }
8603 if let Some(v) = self.end {
8604 ::buffa::encoding::Tag::new(4u32, ::buffa::encoding::WireType::Varint)
8605 .encode(buf);
8606 ::buffa::types::encode_int32(v, buf);
8607 }
8608 if let Some(ref v) = self.semantic {
8609 ::buffa::encoding::Tag::new(5u32, ::buffa::encoding::WireType::Varint)
8610 .encode(buf);
8611 ::buffa::types::encode_int32(v.to_i32(), buf);
8612 }
8613 if !self.path.is_empty() {
8614 let payload: u32 = self
8615 .path
8616 .iter()
8617 .map(|&v| ::buffa::types::int32_encoded_len(v) as u32)
8618 .sum::<u32>();
8619 ::buffa::encoding::Tag::new(
8620 1u32,
8621 ::buffa::encoding::WireType::LengthDelimited,
8622 )
8623 .encode(buf);
8624 ::buffa::encoding::encode_varint(payload as u64, buf);
8625 for &v in &self.path {
8626 ::buffa::types::encode_int32(v, buf);
8627 }
8628 }
8629 self.__buffa_unknown_fields.write_to(buf);
8630 }
8631 fn merge_field(
8632 &mut self,
8633 tag: ::buffa::encoding::Tag,
8634 buf: &mut impl ::buffa::bytes::Buf,
8635 depth: u32,
8636 ) -> ::core::result::Result<(), ::buffa::DecodeError> {
8637 #[allow(unused_imports)]
8638 use ::buffa::bytes::Buf as _;
8639 #[allow(unused_imports)]
8640 use ::buffa::Enumeration as _;
8641 match tag.field_number() {
8642 2u32 => {
8643 if tag.wire_type() != ::buffa::encoding::WireType::LengthDelimited {
8644 return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
8645 field_number: 2u32,
8646 expected: 2u8,
8647 actual: tag.wire_type() as u8,
8648 });
8649 }
8650 ::buffa::types::merge_string(
8651 self
8652 .source_file
8653 .get_or_insert_with(::buffa::alloc::string::String::new),
8654 buf,
8655 )?;
8656 }
8657 3u32 => {
8658 if tag.wire_type() != ::buffa::encoding::WireType::Varint {
8659 return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
8660 field_number: 3u32,
8661 expected: 0u8,
8662 actual: tag.wire_type() as u8,
8663 });
8664 }
8665 self.begin = ::core::option::Option::Some(
8666 ::buffa::types::decode_int32(buf)?,
8667 );
8668 }
8669 4u32 => {
8670 if tag.wire_type() != ::buffa::encoding::WireType::Varint {
8671 return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
8672 field_number: 4u32,
8673 expected: 0u8,
8674 actual: tag.wire_type() as u8,
8675 });
8676 }
8677 self.end = ::core::option::Option::Some(
8678 ::buffa::types::decode_int32(buf)?,
8679 );
8680 }
8681 5u32 => {
8682 if tag.wire_type() != ::buffa::encoding::WireType::Varint {
8683 return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
8684 field_number: 5u32,
8685 expected: 0u8,
8686 actual: tag.wire_type() as u8,
8687 });
8688 }
8689 let __raw = ::buffa::types::decode_int32(buf)?;
8690 if let ::core::option::Option::Some(__v) = ::buffa::Enumeration::from_i32(
8691 __raw,
8692 ) {
8693 self.semantic = ::core::option::Option::Some(__v);
8694 } else {
8695 self.__buffa_unknown_fields
8696 .push(::buffa::UnknownField {
8697 number: 5u32,
8698 data: ::buffa::UnknownFieldData::Varint(__raw as u64),
8699 });
8700 }
8701 }
8702 1u32 => {
8703 if tag.wire_type() == ::buffa::encoding::WireType::LengthDelimited {
8704 let len = ::buffa::encoding::decode_varint(buf)?;
8705 let len = usize::try_from(len)
8706 .map_err(|_| ::buffa::DecodeError::MessageTooLarge)?;
8707 if buf.remaining() < len {
8708 return ::core::result::Result::Err(
8709 ::buffa::DecodeError::UnexpectedEof,
8710 );
8711 }
8712 self.path.reserve(len);
8713 let mut limited = buf.take(len);
8714 while limited.has_remaining() {
8715 self.path.push(::buffa::types::decode_int32(&mut limited)?);
8716 }
8717 let leftover = limited.remaining();
8718 if leftover > 0 {
8719 limited.advance(leftover);
8720 }
8721 } else if tag.wire_type() == ::buffa::encoding::WireType::Varint {
8722 self.path.push(::buffa::types::decode_int32(buf)?);
8723 } else {
8724 return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
8725 field_number: 1u32,
8726 expected: 2u8,
8727 actual: tag.wire_type() as u8,
8728 });
8729 }
8730 }
8731 _ => {
8732 self.__buffa_unknown_fields
8733 .push(::buffa::encoding::decode_unknown_field(tag, buf, depth)?);
8734 }
8735 }
8736 ::core::result::Result::Ok(())
8737 }
8738 fn cached_size(&self) -> u32 {
8739 self.__buffa_cached_size.get()
8740 }
8741 fn clear(&mut self) {
8742 self.source_file = ::core::option::Option::None;
8743 self.begin = ::core::option::Option::None;
8744 self.end = ::core::option::Option::None;
8745 self.semantic = ::core::option::Option::None;
8746 self.path.clear();
8747 self.__buffa_unknown_fields.clear();
8748 self.__buffa_cached_size.set(0);
8749 }
8750 }
8751 pub mod annotation {
8752 #[allow(unused_imports)]
8753 use super::*;
8754 #[derive(Clone, Copy, PartialEq, Eq, Hash, Debug)]
8755 #[repr(i32)]
8756 pub enum Semantic {
8757 NONE = 0i32,
8758 SET = 1i32,
8759 ALIAS = 2i32,
8760 }
8761 impl ::core::default::Default for Semantic {
8762 fn default() -> Self {
8763 Self::NONE
8764 }
8765 }
8766 impl ::buffa::Enumeration for Semantic {
8767 fn from_i32(value: i32) -> ::core::option::Option<Self> {
8768 match value {
8769 0i32 => ::core::option::Option::Some(Self::NONE),
8770 1i32 => ::core::option::Option::Some(Self::SET),
8771 2i32 => ::core::option::Option::Some(Self::ALIAS),
8772 _ => ::core::option::Option::None,
8773 }
8774 }
8775 fn to_i32(&self) -> i32 {
8776 *self as i32
8777 }
8778 fn proto_name(&self) -> &'static str {
8779 match self {
8780 Self::NONE => "NONE",
8781 Self::SET => "SET",
8782 Self::ALIAS => "ALIAS",
8783 }
8784 }
8785 fn from_proto_name(name: &str) -> ::core::option::Option<Self> {
8786 match name {
8787 "NONE" => ::core::option::Option::Some(Self::NONE),
8788 "SET" => ::core::option::Option::Some(Self::SET),
8789 "ALIAS" => ::core::option::Option::Some(Self::ALIAS),
8790 _ => ::core::option::Option::None,
8791 }
8792 }
8793 }
8794 }
8795}