1#[derive(Clone, PartialEq, Default)]
8#[derive(::serde::Serialize)]
9#[serde(default)]
10pub struct PolychartEventEnvelope {
11 #[serde(
13 rename = "serverTsMs",
14 alias = "server_ts_ms",
15 with = "::buffa::json_helpers::uint64",
16 skip_serializing_if = "::buffa::json_helpers::skip_if::is_zero_u64"
17 )]
18 pub server_ts_ms: u64,
19 #[serde(flatten)]
20 pub event: ::core::option::Option<__buffa::oneof::polychart_event_envelope::Event>,
21 #[serde(skip)]
22 #[doc(hidden)]
23 pub __buffa_unknown_fields: ::buffa::UnknownFields,
24}
25impl ::core::fmt::Debug for PolychartEventEnvelope {
26 fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
27 f.debug_struct("PolychartEventEnvelope")
28 .field("server_ts_ms", &self.server_ts_ms)
29 .field("event", &self.event)
30 .finish()
31 }
32}
33impl PolychartEventEnvelope {
34 pub const TYPE_URL: &'static str = "type.googleapis.com/polychart.events.v1.PolychartEventEnvelope";
39}
40::buffa::impl_default_instance!(PolychartEventEnvelope);
41impl ::buffa::MessageName for PolychartEventEnvelope {
42 const PACKAGE: &'static str = "polychart.events.v1";
43 const NAME: &'static str = "PolychartEventEnvelope";
44 const FULL_NAME: &'static str = "polychart.events.v1.PolychartEventEnvelope";
45 const TYPE_URL: &'static str = "type.googleapis.com/polychart.events.v1.PolychartEventEnvelope";
46}
47impl ::buffa::Message for PolychartEventEnvelope {
48 #[allow(clippy::let_and_return)]
54 fn compute_size(&self, __cache: &mut ::buffa::SizeCache) -> u32 {
55 #[allow(unused_imports)]
56 use ::buffa::Enumeration as _;
57 let mut size = 0u32;
58 if self.server_ts_ms != 0u64 {
59 size += 1u32 + ::buffa::types::FIXED64_ENCODED_LEN as u32;
60 }
61 if let ::core::option::Option::Some(ref v) = self.event {
62 match v {
63 __buffa::oneof::polychart_event_envelope::Event::DrawingCommitted(x) => {
64 let __slot = __cache.reserve();
65 let inner = x.compute_size(__cache);
66 __cache.set(__slot, inner);
67 size
68 += 1u32 + ::buffa::encoding::varint_len(inner as u64) as u32
69 + inner;
70 }
71 __buffa::oneof::polychart_event_envelope::Event::DrawingDeleted(x) => {
72 let __slot = __cache.reserve();
73 let inner = x.compute_size(__cache);
74 __cache.set(__slot, inner);
75 size
76 += 1u32 + ::buffa::encoding::varint_len(inner as u64) as u32
77 + inner;
78 }
79 __buffa::oneof::polychart_event_envelope::Event::LayerUpdated(x) => {
80 let __slot = __cache.reserve();
81 let inner = x.compute_size(__cache);
82 __cache.set(__slot, inner);
83 size
84 += 2u32 + ::buffa::encoding::varint_len(inner as u64) as u32
85 + inner;
86 }
87 __buffa::oneof::polychart_event_envelope::Event::LayerDeleted(x) => {
88 let __slot = __cache.reserve();
89 let inner = x.compute_size(__cache);
90 __cache.set(__slot, inner);
91 size
92 += 2u32 + ::buffa::encoding::varint_len(inner as u64) as u32
93 + inner;
94 }
95 __buffa::oneof::polychart_event_envelope::Event::LayerAccessGranted(
96 x,
97 ) => {
98 let __slot = __cache.reserve();
99 let inner = x.compute_size(__cache);
100 __cache.set(__slot, inner);
101 size
102 += 2u32 + ::buffa::encoding::varint_len(inner as u64) as u32
103 + inner;
104 }
105 __buffa::oneof::polychart_event_envelope::Event::LayerAccessRevoked(
106 x,
107 ) => {
108 let __slot = __cache.reserve();
109 let inner = x.compute_size(__cache);
110 __cache.set(__slot, inner);
111 size
112 += 2u32 + ::buffa::encoding::varint_len(inner as u64) as u32
113 + inner;
114 }
115 }
116 }
117 size += self.__buffa_unknown_fields.encoded_len() as u32;
118 size
119 }
120 fn write_to(
121 &self,
122 __cache: &mut ::buffa::SizeCache,
123 buf: &mut impl ::buffa::bytes::BufMut,
124 ) {
125 #[allow(unused_imports)]
126 use ::buffa::Enumeration as _;
127 if self.server_ts_ms != 0u64 {
128 ::buffa::types::put_fixed64_field(1u32, self.server_ts_ms, buf);
129 }
130 if let ::core::option::Option::Some(ref v) = self.event {
131 match v {
132 __buffa::oneof::polychart_event_envelope::Event::DrawingCommitted(x) => {
133 ::buffa::types::put_len_delimited_header(
134 10u32,
135 __cache.consume_next(),
136 buf,
137 );
138 x.write_to(__cache, buf);
139 }
140 __buffa::oneof::polychart_event_envelope::Event::DrawingDeleted(x) => {
141 ::buffa::types::put_len_delimited_header(
142 11u32,
143 __cache.consume_next(),
144 buf,
145 );
146 x.write_to(__cache, buf);
147 }
148 __buffa::oneof::polychart_event_envelope::Event::LayerUpdated(x) => {
149 ::buffa::types::put_len_delimited_header(
150 20u32,
151 __cache.consume_next(),
152 buf,
153 );
154 x.write_to(__cache, buf);
155 }
156 __buffa::oneof::polychart_event_envelope::Event::LayerDeleted(x) => {
157 ::buffa::types::put_len_delimited_header(
158 21u32,
159 __cache.consume_next(),
160 buf,
161 );
162 x.write_to(__cache, buf);
163 }
164 __buffa::oneof::polychart_event_envelope::Event::LayerAccessGranted(
165 x,
166 ) => {
167 ::buffa::types::put_len_delimited_header(
168 30u32,
169 __cache.consume_next(),
170 buf,
171 );
172 x.write_to(__cache, buf);
173 }
174 __buffa::oneof::polychart_event_envelope::Event::LayerAccessRevoked(
175 x,
176 ) => {
177 ::buffa::types::put_len_delimited_header(
178 31u32,
179 __cache.consume_next(),
180 buf,
181 );
182 x.write_to(__cache, buf);
183 }
184 }
185 }
186 self.__buffa_unknown_fields.write_to(buf);
187 }
188 fn merge_field(
189 &mut self,
190 tag: ::buffa::encoding::Tag,
191 buf: &mut impl ::buffa::bytes::Buf,
192 ctx: ::buffa::DecodeContext<'_>,
193 ) -> ::core::result::Result<(), ::buffa::DecodeError> {
194 #[allow(unused_imports)]
195 use ::buffa::bytes::Buf as _;
196 #[allow(unused_imports)]
197 use ::buffa::Enumeration as _;
198 match tag.field_number() {
199 1u32 => {
200 ::buffa::encoding::check_wire_type(
201 tag,
202 ::buffa::encoding::WireType::Fixed64,
203 )?;
204 self.server_ts_ms = ::buffa::types::decode_fixed64(buf)?;
205 }
206 10u32 => {
207 ::buffa::encoding::check_wire_type(
208 tag,
209 ::buffa::encoding::WireType::LengthDelimited,
210 )?;
211 if let ::core::option::Option::Some(
212 __buffa::oneof::polychart_event_envelope::Event::DrawingCommitted(
213 ref mut existing,
214 ),
215 ) = self.event
216 {
217 ::buffa::Message::merge_length_delimited(&mut **existing, buf, ctx)?;
218 } else {
219 let mut val = ::core::default::Default::default();
220 ::buffa::Message::merge_length_delimited(&mut val, buf, ctx)?;
221 self.event = ::core::option::Option::Some(
222 __buffa::oneof::polychart_event_envelope::Event::DrawingCommitted(
223 ::buffa::alloc::boxed::Box::new(val),
224 ),
225 );
226 }
227 }
228 11u32 => {
229 ::buffa::encoding::check_wire_type(
230 tag,
231 ::buffa::encoding::WireType::LengthDelimited,
232 )?;
233 if let ::core::option::Option::Some(
234 __buffa::oneof::polychart_event_envelope::Event::DrawingDeleted(
235 ref mut existing,
236 ),
237 ) = self.event
238 {
239 ::buffa::Message::merge_length_delimited(&mut **existing, buf, ctx)?;
240 } else {
241 let mut val = ::core::default::Default::default();
242 ::buffa::Message::merge_length_delimited(&mut val, buf, ctx)?;
243 self.event = ::core::option::Option::Some(
244 __buffa::oneof::polychart_event_envelope::Event::DrawingDeleted(
245 ::buffa::alloc::boxed::Box::new(val),
246 ),
247 );
248 }
249 }
250 20u32 => {
251 ::buffa::encoding::check_wire_type(
252 tag,
253 ::buffa::encoding::WireType::LengthDelimited,
254 )?;
255 if let ::core::option::Option::Some(
256 __buffa::oneof::polychart_event_envelope::Event::LayerUpdated(
257 ref mut existing,
258 ),
259 ) = self.event
260 {
261 ::buffa::Message::merge_length_delimited(&mut **existing, buf, ctx)?;
262 } else {
263 let mut val = ::core::default::Default::default();
264 ::buffa::Message::merge_length_delimited(&mut val, buf, ctx)?;
265 self.event = ::core::option::Option::Some(
266 __buffa::oneof::polychart_event_envelope::Event::LayerUpdated(
267 ::buffa::alloc::boxed::Box::new(val),
268 ),
269 );
270 }
271 }
272 21u32 => {
273 ::buffa::encoding::check_wire_type(
274 tag,
275 ::buffa::encoding::WireType::LengthDelimited,
276 )?;
277 if let ::core::option::Option::Some(
278 __buffa::oneof::polychart_event_envelope::Event::LayerDeleted(
279 ref mut existing,
280 ),
281 ) = self.event
282 {
283 ::buffa::Message::merge_length_delimited(&mut **existing, buf, ctx)?;
284 } else {
285 let mut val = ::core::default::Default::default();
286 ::buffa::Message::merge_length_delimited(&mut val, buf, ctx)?;
287 self.event = ::core::option::Option::Some(
288 __buffa::oneof::polychart_event_envelope::Event::LayerDeleted(
289 ::buffa::alloc::boxed::Box::new(val),
290 ),
291 );
292 }
293 }
294 30u32 => {
295 ::buffa::encoding::check_wire_type(
296 tag,
297 ::buffa::encoding::WireType::LengthDelimited,
298 )?;
299 if let ::core::option::Option::Some(
300 __buffa::oneof::polychart_event_envelope::Event::LayerAccessGranted(
301 ref mut existing,
302 ),
303 ) = self.event
304 {
305 ::buffa::Message::merge_length_delimited(&mut **existing, buf, ctx)?;
306 } else {
307 let mut val = ::core::default::Default::default();
308 ::buffa::Message::merge_length_delimited(&mut val, buf, ctx)?;
309 self.event = ::core::option::Option::Some(
310 __buffa::oneof::polychart_event_envelope::Event::LayerAccessGranted(
311 ::buffa::alloc::boxed::Box::new(val),
312 ),
313 );
314 }
315 }
316 31u32 => {
317 ::buffa::encoding::check_wire_type(
318 tag,
319 ::buffa::encoding::WireType::LengthDelimited,
320 )?;
321 if let ::core::option::Option::Some(
322 __buffa::oneof::polychart_event_envelope::Event::LayerAccessRevoked(
323 ref mut existing,
324 ),
325 ) = self.event
326 {
327 ::buffa::Message::merge_length_delimited(&mut **existing, buf, ctx)?;
328 } else {
329 let mut val = ::core::default::Default::default();
330 ::buffa::Message::merge_length_delimited(&mut val, buf, ctx)?;
331 self.event = ::core::option::Option::Some(
332 __buffa::oneof::polychart_event_envelope::Event::LayerAccessRevoked(
333 ::buffa::alloc::boxed::Box::new(val),
334 ),
335 );
336 }
337 }
338 _ => {
339 self.__buffa_unknown_fields
340 .push(::buffa::encoding::decode_unknown_field(tag, buf, ctx)?);
341 }
342 }
343 ::core::result::Result::Ok(())
344 }
345 fn clear(&mut self) {
346 self.server_ts_ms = 0u64;
347 self.event = ::core::option::Option::None;
348 self.__buffa_unknown_fields.clear();
349 }
350}
351impl ::buffa::ExtensionSet for PolychartEventEnvelope {
352 const PROTO_FQN: &'static str = "polychart.events.v1.PolychartEventEnvelope";
353 fn unknown_fields(&self) -> &::buffa::UnknownFields {
354 &self.__buffa_unknown_fields
355 }
356 fn unknown_fields_mut(&mut self) -> &mut ::buffa::UnknownFields {
357 &mut self.__buffa_unknown_fields
358 }
359}
360impl<'de> serde::Deserialize<'de> for PolychartEventEnvelope {
361 fn deserialize<D: serde::Deserializer<'de>>(
362 d: D,
363 ) -> ::core::result::Result<Self, D::Error> {
364 struct _V;
365 impl<'de> serde::de::Visitor<'de> for _V {
366 type Value = PolychartEventEnvelope;
367 fn expecting(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
368 f.write_str("struct PolychartEventEnvelope")
369 }
370 #[allow(clippy::field_reassign_with_default)]
371 fn visit_map<A: serde::de::MapAccess<'de>>(
372 self,
373 mut map: A,
374 ) -> ::core::result::Result<PolychartEventEnvelope, A::Error> {
375 let mut __f_server_ts_ms: ::core::option::Option<u64> = None;
376 let mut __oneof_event: ::core::option::Option<
377 __buffa::oneof::polychart_event_envelope::Event,
378 > = None;
379 while let Some(key) = map.next_key::<::buffa::alloc::string::String>()? {
380 match key.as_str() {
381 "serverTsMs" | "server_ts_ms" => {
382 __f_server_ts_ms = Some({
383 struct _S;
384 impl<'de> serde::de::DeserializeSeed<'de> for _S {
385 type Value = u64;
386 fn deserialize<D: serde::Deserializer<'de>>(
387 self,
388 d: D,
389 ) -> ::core::result::Result<u64, D::Error> {
390 ::buffa::json_helpers::uint64::deserialize(d)
391 }
392 }
393 map.next_value_seed(_S)?
394 });
395 }
396 "drawingCommitted" | "drawing_committed" => {
397 let v: ::core::option::Option<DrawingCommitted> = map
398 .next_value_seed(
399 ::buffa::json_helpers::NullableDeserializeSeed(
400 ::buffa::json_helpers::DefaultDeserializeSeed::<
401 DrawingCommitted,
402 >::new(),
403 ),
404 )?;
405 if let Some(v) = v {
406 if __oneof_event.is_some() {
407 return Err(
408 serde::de::Error::custom(
409 "multiple oneof fields set for 'event'",
410 ),
411 );
412 }
413 __oneof_event = Some(
414 __buffa::oneof::polychart_event_envelope::Event::DrawingCommitted(
415 ::buffa::alloc::boxed::Box::new(v),
416 ),
417 );
418 }
419 }
420 "drawingDeleted" | "drawing_deleted" => {
421 let v: ::core::option::Option<DrawingDeleted> = map
422 .next_value_seed(
423 ::buffa::json_helpers::NullableDeserializeSeed(
424 ::buffa::json_helpers::DefaultDeserializeSeed::<
425 DrawingDeleted,
426 >::new(),
427 ),
428 )?;
429 if let Some(v) = v {
430 if __oneof_event.is_some() {
431 return Err(
432 serde::de::Error::custom(
433 "multiple oneof fields set for 'event'",
434 ),
435 );
436 }
437 __oneof_event = Some(
438 __buffa::oneof::polychart_event_envelope::Event::DrawingDeleted(
439 ::buffa::alloc::boxed::Box::new(v),
440 ),
441 );
442 }
443 }
444 "layerUpdated" | "layer_updated" => {
445 let v: ::core::option::Option<LayerUpdated> = map
446 .next_value_seed(
447 ::buffa::json_helpers::NullableDeserializeSeed(
448 ::buffa::json_helpers::DefaultDeserializeSeed::<
449 LayerUpdated,
450 >::new(),
451 ),
452 )?;
453 if let Some(v) = v {
454 if __oneof_event.is_some() {
455 return Err(
456 serde::de::Error::custom(
457 "multiple oneof fields set for 'event'",
458 ),
459 );
460 }
461 __oneof_event = Some(
462 __buffa::oneof::polychart_event_envelope::Event::LayerUpdated(
463 ::buffa::alloc::boxed::Box::new(v),
464 ),
465 );
466 }
467 }
468 "layerDeleted" | "layer_deleted" => {
469 let v: ::core::option::Option<LayerDeleted> = map
470 .next_value_seed(
471 ::buffa::json_helpers::NullableDeserializeSeed(
472 ::buffa::json_helpers::DefaultDeserializeSeed::<
473 LayerDeleted,
474 >::new(),
475 ),
476 )?;
477 if let Some(v) = v {
478 if __oneof_event.is_some() {
479 return Err(
480 serde::de::Error::custom(
481 "multiple oneof fields set for 'event'",
482 ),
483 );
484 }
485 __oneof_event = Some(
486 __buffa::oneof::polychart_event_envelope::Event::LayerDeleted(
487 ::buffa::alloc::boxed::Box::new(v),
488 ),
489 );
490 }
491 }
492 "layerAccessGranted" | "layer_access_granted" => {
493 let v: ::core::option::Option<LayerAccessGranted> = map
494 .next_value_seed(
495 ::buffa::json_helpers::NullableDeserializeSeed(
496 ::buffa::json_helpers::DefaultDeserializeSeed::<
497 LayerAccessGranted,
498 >::new(),
499 ),
500 )?;
501 if let Some(v) = v {
502 if __oneof_event.is_some() {
503 return Err(
504 serde::de::Error::custom(
505 "multiple oneof fields set for 'event'",
506 ),
507 );
508 }
509 __oneof_event = Some(
510 __buffa::oneof::polychart_event_envelope::Event::LayerAccessGranted(
511 ::buffa::alloc::boxed::Box::new(v),
512 ),
513 );
514 }
515 }
516 "layerAccessRevoked" | "layer_access_revoked" => {
517 let v: ::core::option::Option<LayerAccessRevoked> = map
518 .next_value_seed(
519 ::buffa::json_helpers::NullableDeserializeSeed(
520 ::buffa::json_helpers::DefaultDeserializeSeed::<
521 LayerAccessRevoked,
522 >::new(),
523 ),
524 )?;
525 if let Some(v) = v {
526 if __oneof_event.is_some() {
527 return Err(
528 serde::de::Error::custom(
529 "multiple oneof fields set for 'event'",
530 ),
531 );
532 }
533 __oneof_event = Some(
534 __buffa::oneof::polychart_event_envelope::Event::LayerAccessRevoked(
535 ::buffa::alloc::boxed::Box::new(v),
536 ),
537 );
538 }
539 }
540 _ => {
541 map.next_value::<serde::de::IgnoredAny>()?;
542 }
543 }
544 }
545 let mut __r = <PolychartEventEnvelope as ::core::default::Default>::default();
546 if let ::core::option::Option::Some(v) = __f_server_ts_ms {
547 __r.server_ts_ms = v;
548 }
549 __r.event = __oneof_event;
550 Ok(__r)
551 }
552 }
553 d.deserialize_map(_V)
554 }
555}
556impl ::buffa::json_helpers::ProtoElemJson for PolychartEventEnvelope {
557 fn serialize_proto_json<S: ::serde::Serializer>(
558 v: &Self,
559 s: S,
560 ) -> ::core::result::Result<S::Ok, S::Error> {
561 ::serde::Serialize::serialize(v, s)
562 }
563 fn deserialize_proto_json<'de, D: ::serde::Deserializer<'de>>(
564 d: D,
565 ) -> ::core::result::Result<Self, D::Error> {
566 <Self as ::serde::Deserialize>::deserialize(d)
567 }
568}
569#[doc(hidden)]
570pub const __POLYCHART_EVENT_ENVELOPE_JSON_ANY: ::buffa::type_registry::JsonAnyEntry = ::buffa::type_registry::JsonAnyEntry {
571 type_url: "type.googleapis.com/polychart.events.v1.PolychartEventEnvelope",
572 to_json: ::buffa::type_registry::any_to_json::<PolychartEventEnvelope>,
573 from_json: ::buffa::type_registry::any_from_json::<PolychartEventEnvelope>,
574 is_wkt: false,
575};
576pub mod polychart_event_envelope {
577 #[allow(unused_imports)]
578 use super::*;
579 #[doc(inline)]
580 pub use super::__buffa::oneof::polychart_event_envelope::Event;
581 #[doc(inline)]
582 pub use super::__buffa::view::oneof::polychart_event_envelope::Event as EventView;
583}
584#[derive(Clone, PartialEq, Default)]
585#[derive(::serde::Serialize, ::serde::Deserialize)]
586#[serde(default)]
587pub struct DrawingCommitted {
588 #[serde(
590 rename = "drawing",
591 skip_serializing_if = "::buffa::json_helpers::skip_if::is_unset_message_field"
592 )]
593 pub drawing: ::buffa::MessageField<super::super::v1::Drawing>,
594 #[serde(
598 rename = "layerRevision",
599 alias = "layer_revision",
600 with = "::buffa::json_helpers::uint64",
601 skip_serializing_if = "::buffa::json_helpers::skip_if::is_zero_u64"
602 )]
603 pub layer_revision: u64,
604 #[serde(skip)]
605 #[doc(hidden)]
606 pub __buffa_unknown_fields: ::buffa::UnknownFields,
607}
608impl ::core::fmt::Debug for DrawingCommitted {
609 fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
610 f.debug_struct("DrawingCommitted")
611 .field("drawing", &self.drawing)
612 .field("layer_revision", &self.layer_revision)
613 .finish()
614 }
615}
616impl DrawingCommitted {
617 pub const TYPE_URL: &'static str = "type.googleapis.com/polychart.events.v1.DrawingCommitted";
622}
623::buffa::impl_default_instance!(DrawingCommitted);
624impl ::buffa::MessageName for DrawingCommitted {
625 const PACKAGE: &'static str = "polychart.events.v1";
626 const NAME: &'static str = "DrawingCommitted";
627 const FULL_NAME: &'static str = "polychart.events.v1.DrawingCommitted";
628 const TYPE_URL: &'static str = "type.googleapis.com/polychart.events.v1.DrawingCommitted";
629}
630impl ::buffa::Message for DrawingCommitted {
631 #[allow(clippy::let_and_return)]
637 fn compute_size(&self, __cache: &mut ::buffa::SizeCache) -> u32 {
638 #[allow(unused_imports)]
639 use ::buffa::Enumeration as _;
640 let mut size = 0u32;
641 if self.drawing.is_set() {
642 let __slot = __cache.reserve();
643 let inner_size = self.drawing.compute_size(__cache);
644 __cache.set(__slot, inner_size);
645 size
646 += 1u32 + ::buffa::encoding::varint_len(inner_size as u64) as u32
647 + inner_size;
648 }
649 if self.layer_revision != 0u64 {
650 size += 1u32 + ::buffa::types::FIXED64_ENCODED_LEN as u32;
651 }
652 size += self.__buffa_unknown_fields.encoded_len() as u32;
653 size
654 }
655 fn write_to(
656 &self,
657 __cache: &mut ::buffa::SizeCache,
658 buf: &mut impl ::buffa::bytes::BufMut,
659 ) {
660 #[allow(unused_imports)]
661 use ::buffa::Enumeration as _;
662 if self.drawing.is_set() {
663 ::buffa::types::put_len_delimited_header(1u32, __cache.consume_next(), buf);
664 self.drawing.write_to(__cache, buf);
665 }
666 if self.layer_revision != 0u64 {
667 ::buffa::types::put_fixed64_field(2u32, self.layer_revision, buf);
668 }
669 self.__buffa_unknown_fields.write_to(buf);
670 }
671 fn merge_field(
672 &mut self,
673 tag: ::buffa::encoding::Tag,
674 buf: &mut impl ::buffa::bytes::Buf,
675 ctx: ::buffa::DecodeContext<'_>,
676 ) -> ::core::result::Result<(), ::buffa::DecodeError> {
677 #[allow(unused_imports)]
678 use ::buffa::bytes::Buf as _;
679 #[allow(unused_imports)]
680 use ::buffa::Enumeration as _;
681 match tag.field_number() {
682 1u32 => {
683 ::buffa::encoding::check_wire_type(
684 tag,
685 ::buffa::encoding::WireType::LengthDelimited,
686 )?;
687 ::buffa::Message::merge_length_delimited(
688 self.drawing.get_or_insert_default(),
689 buf,
690 ctx,
691 )?;
692 }
693 2u32 => {
694 ::buffa::encoding::check_wire_type(
695 tag,
696 ::buffa::encoding::WireType::Fixed64,
697 )?;
698 self.layer_revision = ::buffa::types::decode_fixed64(buf)?;
699 }
700 _ => {
701 self.__buffa_unknown_fields
702 .push(::buffa::encoding::decode_unknown_field(tag, buf, ctx)?);
703 }
704 }
705 ::core::result::Result::Ok(())
706 }
707 fn clear(&mut self) {
708 self.drawing = ::buffa::MessageField::none();
709 self.layer_revision = 0u64;
710 self.__buffa_unknown_fields.clear();
711 }
712}
713impl ::buffa::ExtensionSet for DrawingCommitted {
714 const PROTO_FQN: &'static str = "polychart.events.v1.DrawingCommitted";
715 fn unknown_fields(&self) -> &::buffa::UnknownFields {
716 &self.__buffa_unknown_fields
717 }
718 fn unknown_fields_mut(&mut self) -> &mut ::buffa::UnknownFields {
719 &mut self.__buffa_unknown_fields
720 }
721}
722impl ::buffa::json_helpers::ProtoElemJson for DrawingCommitted {
723 fn serialize_proto_json<S: ::serde::Serializer>(
724 v: &Self,
725 s: S,
726 ) -> ::core::result::Result<S::Ok, S::Error> {
727 ::serde::Serialize::serialize(v, s)
728 }
729 fn deserialize_proto_json<'de, D: ::serde::Deserializer<'de>>(
730 d: D,
731 ) -> ::core::result::Result<Self, D::Error> {
732 <Self as ::serde::Deserialize>::deserialize(d)
733 }
734}
735#[doc(hidden)]
736pub const __DRAWING_COMMITTED_JSON_ANY: ::buffa::type_registry::JsonAnyEntry = ::buffa::type_registry::JsonAnyEntry {
737 type_url: "type.googleapis.com/polychart.events.v1.DrawingCommitted",
738 to_json: ::buffa::type_registry::any_to_json::<DrawingCommitted>,
739 from_json: ::buffa::type_registry::any_from_json::<DrawingCommitted>,
740 is_wkt: false,
741};
742#[derive(Clone, PartialEq, Default)]
743#[derive(::serde::Serialize, ::serde::Deserialize)]
744#[serde(default)]
745pub struct DrawingDeleted {
746 #[serde(
748 rename = "drawing",
749 skip_serializing_if = "::buffa::json_helpers::skip_if::is_unset_message_field"
750 )]
751 pub drawing: ::buffa::MessageField<super::super::v1::DrawingRef>,
752 #[serde(
754 rename = "layer",
755 skip_serializing_if = "::buffa::json_helpers::skip_if::is_unset_message_field"
756 )]
757 pub layer: ::buffa::MessageField<super::super::v1::LayerRef>,
758 #[serde(
760 rename = "layerRevision",
761 alias = "layer_revision",
762 with = "::buffa::json_helpers::uint64",
763 skip_serializing_if = "::buffa::json_helpers::skip_if::is_zero_u64"
764 )]
765 pub layer_revision: u64,
766 #[serde(skip)]
767 #[doc(hidden)]
768 pub __buffa_unknown_fields: ::buffa::UnknownFields,
769}
770impl ::core::fmt::Debug for DrawingDeleted {
771 fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
772 f.debug_struct("DrawingDeleted")
773 .field("drawing", &self.drawing)
774 .field("layer", &self.layer)
775 .field("layer_revision", &self.layer_revision)
776 .finish()
777 }
778}
779impl DrawingDeleted {
780 pub const TYPE_URL: &'static str = "type.googleapis.com/polychart.events.v1.DrawingDeleted";
785}
786::buffa::impl_default_instance!(DrawingDeleted);
787impl ::buffa::MessageName for DrawingDeleted {
788 const PACKAGE: &'static str = "polychart.events.v1";
789 const NAME: &'static str = "DrawingDeleted";
790 const FULL_NAME: &'static str = "polychart.events.v1.DrawingDeleted";
791 const TYPE_URL: &'static str = "type.googleapis.com/polychart.events.v1.DrawingDeleted";
792}
793impl ::buffa::Message for DrawingDeleted {
794 #[allow(clippy::let_and_return)]
800 fn compute_size(&self, __cache: &mut ::buffa::SizeCache) -> u32 {
801 #[allow(unused_imports)]
802 use ::buffa::Enumeration as _;
803 let mut size = 0u32;
804 if self.drawing.is_set() {
805 let __slot = __cache.reserve();
806 let inner_size = self.drawing.compute_size(__cache);
807 __cache.set(__slot, inner_size);
808 size
809 += 1u32 + ::buffa::encoding::varint_len(inner_size as u64) as u32
810 + inner_size;
811 }
812 if self.layer.is_set() {
813 let __slot = __cache.reserve();
814 let inner_size = self.layer.compute_size(__cache);
815 __cache.set(__slot, inner_size);
816 size
817 += 1u32 + ::buffa::encoding::varint_len(inner_size as u64) as u32
818 + inner_size;
819 }
820 if self.layer_revision != 0u64 {
821 size += 1u32 + ::buffa::types::FIXED64_ENCODED_LEN as u32;
822 }
823 size += self.__buffa_unknown_fields.encoded_len() as u32;
824 size
825 }
826 fn write_to(
827 &self,
828 __cache: &mut ::buffa::SizeCache,
829 buf: &mut impl ::buffa::bytes::BufMut,
830 ) {
831 #[allow(unused_imports)]
832 use ::buffa::Enumeration as _;
833 if self.drawing.is_set() {
834 ::buffa::types::put_len_delimited_header(1u32, __cache.consume_next(), buf);
835 self.drawing.write_to(__cache, buf);
836 }
837 if self.layer.is_set() {
838 ::buffa::types::put_len_delimited_header(2u32, __cache.consume_next(), buf);
839 self.layer.write_to(__cache, buf);
840 }
841 if self.layer_revision != 0u64 {
842 ::buffa::types::put_fixed64_field(3u32, self.layer_revision, buf);
843 }
844 self.__buffa_unknown_fields.write_to(buf);
845 }
846 fn merge_field(
847 &mut self,
848 tag: ::buffa::encoding::Tag,
849 buf: &mut impl ::buffa::bytes::Buf,
850 ctx: ::buffa::DecodeContext<'_>,
851 ) -> ::core::result::Result<(), ::buffa::DecodeError> {
852 #[allow(unused_imports)]
853 use ::buffa::bytes::Buf as _;
854 #[allow(unused_imports)]
855 use ::buffa::Enumeration as _;
856 match tag.field_number() {
857 1u32 => {
858 ::buffa::encoding::check_wire_type(
859 tag,
860 ::buffa::encoding::WireType::LengthDelimited,
861 )?;
862 ::buffa::Message::merge_length_delimited(
863 self.drawing.get_or_insert_default(),
864 buf,
865 ctx,
866 )?;
867 }
868 2u32 => {
869 ::buffa::encoding::check_wire_type(
870 tag,
871 ::buffa::encoding::WireType::LengthDelimited,
872 )?;
873 ::buffa::Message::merge_length_delimited(
874 self.layer.get_or_insert_default(),
875 buf,
876 ctx,
877 )?;
878 }
879 3u32 => {
880 ::buffa::encoding::check_wire_type(
881 tag,
882 ::buffa::encoding::WireType::Fixed64,
883 )?;
884 self.layer_revision = ::buffa::types::decode_fixed64(buf)?;
885 }
886 _ => {
887 self.__buffa_unknown_fields
888 .push(::buffa::encoding::decode_unknown_field(tag, buf, ctx)?);
889 }
890 }
891 ::core::result::Result::Ok(())
892 }
893 fn clear(&mut self) {
894 self.drawing = ::buffa::MessageField::none();
895 self.layer = ::buffa::MessageField::none();
896 self.layer_revision = 0u64;
897 self.__buffa_unknown_fields.clear();
898 }
899}
900impl ::buffa::ExtensionSet for DrawingDeleted {
901 const PROTO_FQN: &'static str = "polychart.events.v1.DrawingDeleted";
902 fn unknown_fields(&self) -> &::buffa::UnknownFields {
903 &self.__buffa_unknown_fields
904 }
905 fn unknown_fields_mut(&mut self) -> &mut ::buffa::UnknownFields {
906 &mut self.__buffa_unknown_fields
907 }
908}
909impl ::buffa::json_helpers::ProtoElemJson for DrawingDeleted {
910 fn serialize_proto_json<S: ::serde::Serializer>(
911 v: &Self,
912 s: S,
913 ) -> ::core::result::Result<S::Ok, S::Error> {
914 ::serde::Serialize::serialize(v, s)
915 }
916 fn deserialize_proto_json<'de, D: ::serde::Deserializer<'de>>(
917 d: D,
918 ) -> ::core::result::Result<Self, D::Error> {
919 <Self as ::serde::Deserialize>::deserialize(d)
920 }
921}
922#[doc(hidden)]
923pub const __DRAWING_DELETED_JSON_ANY: ::buffa::type_registry::JsonAnyEntry = ::buffa::type_registry::JsonAnyEntry {
924 type_url: "type.googleapis.com/polychart.events.v1.DrawingDeleted",
925 to_json: ::buffa::type_registry::any_to_json::<DrawingDeleted>,
926 from_json: ::buffa::type_registry::any_from_json::<DrawingDeleted>,
927 is_wkt: false,
928};
929#[derive(Clone, PartialEq, Default)]
930#[derive(::serde::Serialize, ::serde::Deserialize)]
931#[serde(default)]
932pub struct LayerUpdated {
933 #[serde(
935 rename = "layer",
936 skip_serializing_if = "::buffa::json_helpers::skip_if::is_unset_message_field"
937 )]
938 pub layer: ::buffa::MessageField<super::super::v1::Layer>,
939 #[serde(skip)]
940 #[doc(hidden)]
941 pub __buffa_unknown_fields: ::buffa::UnknownFields,
942}
943impl ::core::fmt::Debug for LayerUpdated {
944 fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
945 f.debug_struct("LayerUpdated").field("layer", &self.layer).finish()
946 }
947}
948impl LayerUpdated {
949 pub const TYPE_URL: &'static str = "type.googleapis.com/polychart.events.v1.LayerUpdated";
954}
955::buffa::impl_default_instance!(LayerUpdated);
956impl ::buffa::MessageName for LayerUpdated {
957 const PACKAGE: &'static str = "polychart.events.v1";
958 const NAME: &'static str = "LayerUpdated";
959 const FULL_NAME: &'static str = "polychart.events.v1.LayerUpdated";
960 const TYPE_URL: &'static str = "type.googleapis.com/polychart.events.v1.LayerUpdated";
961}
962impl ::buffa::Message for LayerUpdated {
963 #[allow(clippy::let_and_return)]
969 fn compute_size(&self, __cache: &mut ::buffa::SizeCache) -> u32 {
970 #[allow(unused_imports)]
971 use ::buffa::Enumeration as _;
972 let mut size = 0u32;
973 if self.layer.is_set() {
974 let __slot = __cache.reserve();
975 let inner_size = self.layer.compute_size(__cache);
976 __cache.set(__slot, inner_size);
977 size
978 += 1u32 + ::buffa::encoding::varint_len(inner_size as u64) as u32
979 + inner_size;
980 }
981 size += self.__buffa_unknown_fields.encoded_len() as u32;
982 size
983 }
984 fn write_to(
985 &self,
986 __cache: &mut ::buffa::SizeCache,
987 buf: &mut impl ::buffa::bytes::BufMut,
988 ) {
989 #[allow(unused_imports)]
990 use ::buffa::Enumeration as _;
991 if self.layer.is_set() {
992 ::buffa::types::put_len_delimited_header(1u32, __cache.consume_next(), buf);
993 self.layer.write_to(__cache, buf);
994 }
995 self.__buffa_unknown_fields.write_to(buf);
996 }
997 fn merge_field(
998 &mut self,
999 tag: ::buffa::encoding::Tag,
1000 buf: &mut impl ::buffa::bytes::Buf,
1001 ctx: ::buffa::DecodeContext<'_>,
1002 ) -> ::core::result::Result<(), ::buffa::DecodeError> {
1003 #[allow(unused_imports)]
1004 use ::buffa::bytes::Buf as _;
1005 #[allow(unused_imports)]
1006 use ::buffa::Enumeration as _;
1007 match tag.field_number() {
1008 1u32 => {
1009 ::buffa::encoding::check_wire_type(
1010 tag,
1011 ::buffa::encoding::WireType::LengthDelimited,
1012 )?;
1013 ::buffa::Message::merge_length_delimited(
1014 self.layer.get_or_insert_default(),
1015 buf,
1016 ctx,
1017 )?;
1018 }
1019 _ => {
1020 self.__buffa_unknown_fields
1021 .push(::buffa::encoding::decode_unknown_field(tag, buf, ctx)?);
1022 }
1023 }
1024 ::core::result::Result::Ok(())
1025 }
1026 fn clear(&mut self) {
1027 self.layer = ::buffa::MessageField::none();
1028 self.__buffa_unknown_fields.clear();
1029 }
1030}
1031impl ::buffa::ExtensionSet for LayerUpdated {
1032 const PROTO_FQN: &'static str = "polychart.events.v1.LayerUpdated";
1033 fn unknown_fields(&self) -> &::buffa::UnknownFields {
1034 &self.__buffa_unknown_fields
1035 }
1036 fn unknown_fields_mut(&mut self) -> &mut ::buffa::UnknownFields {
1037 &mut self.__buffa_unknown_fields
1038 }
1039}
1040impl ::buffa::json_helpers::ProtoElemJson for LayerUpdated {
1041 fn serialize_proto_json<S: ::serde::Serializer>(
1042 v: &Self,
1043 s: S,
1044 ) -> ::core::result::Result<S::Ok, S::Error> {
1045 ::serde::Serialize::serialize(v, s)
1046 }
1047 fn deserialize_proto_json<'de, D: ::serde::Deserializer<'de>>(
1048 d: D,
1049 ) -> ::core::result::Result<Self, D::Error> {
1050 <Self as ::serde::Deserialize>::deserialize(d)
1051 }
1052}
1053#[doc(hidden)]
1054pub const __LAYER_UPDATED_JSON_ANY: ::buffa::type_registry::JsonAnyEntry = ::buffa::type_registry::JsonAnyEntry {
1055 type_url: "type.googleapis.com/polychart.events.v1.LayerUpdated",
1056 to_json: ::buffa::type_registry::any_to_json::<LayerUpdated>,
1057 from_json: ::buffa::type_registry::any_from_json::<LayerUpdated>,
1058 is_wkt: false,
1059};
1060#[derive(Clone, PartialEq, Default)]
1061#[derive(::serde::Serialize, ::serde::Deserialize)]
1062#[serde(default)]
1063pub struct LayerDeleted {
1064 #[serde(
1068 rename = "layer",
1069 skip_serializing_if = "::buffa::json_helpers::skip_if::is_unset_message_field"
1070 )]
1071 pub layer: ::buffa::MessageField<super::super::v1::LayerRef>,
1072 #[serde(
1076 rename = "layerRevision",
1077 alias = "layer_revision",
1078 with = "::buffa::json_helpers::uint64",
1079 skip_serializing_if = "::buffa::json_helpers::skip_if::is_zero_u64"
1080 )]
1081 pub layer_revision: u64,
1082 #[serde(skip)]
1083 #[doc(hidden)]
1084 pub __buffa_unknown_fields: ::buffa::UnknownFields,
1085}
1086impl ::core::fmt::Debug for LayerDeleted {
1087 fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
1088 f.debug_struct("LayerDeleted")
1089 .field("layer", &self.layer)
1090 .field("layer_revision", &self.layer_revision)
1091 .finish()
1092 }
1093}
1094impl LayerDeleted {
1095 pub const TYPE_URL: &'static str = "type.googleapis.com/polychart.events.v1.LayerDeleted";
1100}
1101::buffa::impl_default_instance!(LayerDeleted);
1102impl ::buffa::MessageName for LayerDeleted {
1103 const PACKAGE: &'static str = "polychart.events.v1";
1104 const NAME: &'static str = "LayerDeleted";
1105 const FULL_NAME: &'static str = "polychart.events.v1.LayerDeleted";
1106 const TYPE_URL: &'static str = "type.googleapis.com/polychart.events.v1.LayerDeleted";
1107}
1108impl ::buffa::Message for LayerDeleted {
1109 #[allow(clippy::let_and_return)]
1115 fn compute_size(&self, __cache: &mut ::buffa::SizeCache) -> u32 {
1116 #[allow(unused_imports)]
1117 use ::buffa::Enumeration as _;
1118 let mut size = 0u32;
1119 if self.layer.is_set() {
1120 let __slot = __cache.reserve();
1121 let inner_size = self.layer.compute_size(__cache);
1122 __cache.set(__slot, inner_size);
1123 size
1124 += 1u32 + ::buffa::encoding::varint_len(inner_size as u64) as u32
1125 + inner_size;
1126 }
1127 if self.layer_revision != 0u64 {
1128 size += 1u32 + ::buffa::types::FIXED64_ENCODED_LEN as u32;
1129 }
1130 size += self.__buffa_unknown_fields.encoded_len() as u32;
1131 size
1132 }
1133 fn write_to(
1134 &self,
1135 __cache: &mut ::buffa::SizeCache,
1136 buf: &mut impl ::buffa::bytes::BufMut,
1137 ) {
1138 #[allow(unused_imports)]
1139 use ::buffa::Enumeration as _;
1140 if self.layer.is_set() {
1141 ::buffa::types::put_len_delimited_header(1u32, __cache.consume_next(), buf);
1142 self.layer.write_to(__cache, buf);
1143 }
1144 if self.layer_revision != 0u64 {
1145 ::buffa::types::put_fixed64_field(2u32, self.layer_revision, buf);
1146 }
1147 self.__buffa_unknown_fields.write_to(buf);
1148 }
1149 fn merge_field(
1150 &mut self,
1151 tag: ::buffa::encoding::Tag,
1152 buf: &mut impl ::buffa::bytes::Buf,
1153 ctx: ::buffa::DecodeContext<'_>,
1154 ) -> ::core::result::Result<(), ::buffa::DecodeError> {
1155 #[allow(unused_imports)]
1156 use ::buffa::bytes::Buf as _;
1157 #[allow(unused_imports)]
1158 use ::buffa::Enumeration as _;
1159 match tag.field_number() {
1160 1u32 => {
1161 ::buffa::encoding::check_wire_type(
1162 tag,
1163 ::buffa::encoding::WireType::LengthDelimited,
1164 )?;
1165 ::buffa::Message::merge_length_delimited(
1166 self.layer.get_or_insert_default(),
1167 buf,
1168 ctx,
1169 )?;
1170 }
1171 2u32 => {
1172 ::buffa::encoding::check_wire_type(
1173 tag,
1174 ::buffa::encoding::WireType::Fixed64,
1175 )?;
1176 self.layer_revision = ::buffa::types::decode_fixed64(buf)?;
1177 }
1178 _ => {
1179 self.__buffa_unknown_fields
1180 .push(::buffa::encoding::decode_unknown_field(tag, buf, ctx)?);
1181 }
1182 }
1183 ::core::result::Result::Ok(())
1184 }
1185 fn clear(&mut self) {
1186 self.layer = ::buffa::MessageField::none();
1187 self.layer_revision = 0u64;
1188 self.__buffa_unknown_fields.clear();
1189 }
1190}
1191impl ::buffa::ExtensionSet for LayerDeleted {
1192 const PROTO_FQN: &'static str = "polychart.events.v1.LayerDeleted";
1193 fn unknown_fields(&self) -> &::buffa::UnknownFields {
1194 &self.__buffa_unknown_fields
1195 }
1196 fn unknown_fields_mut(&mut self) -> &mut ::buffa::UnknownFields {
1197 &mut self.__buffa_unknown_fields
1198 }
1199}
1200impl ::buffa::json_helpers::ProtoElemJson for LayerDeleted {
1201 fn serialize_proto_json<S: ::serde::Serializer>(
1202 v: &Self,
1203 s: S,
1204 ) -> ::core::result::Result<S::Ok, S::Error> {
1205 ::serde::Serialize::serialize(v, s)
1206 }
1207 fn deserialize_proto_json<'de, D: ::serde::Deserializer<'de>>(
1208 d: D,
1209 ) -> ::core::result::Result<Self, D::Error> {
1210 <Self as ::serde::Deserialize>::deserialize(d)
1211 }
1212}
1213#[doc(hidden)]
1214pub const __LAYER_DELETED_JSON_ANY: ::buffa::type_registry::JsonAnyEntry = ::buffa::type_registry::JsonAnyEntry {
1215 type_url: "type.googleapis.com/polychart.events.v1.LayerDeleted",
1216 to_json: ::buffa::type_registry::any_to_json::<LayerDeleted>,
1217 from_json: ::buffa::type_registry::any_from_json::<LayerDeleted>,
1218 is_wkt: false,
1219};
1220#[derive(Clone, PartialEq, Default)]
1221#[derive(::serde::Serialize, ::serde::Deserialize)]
1222#[serde(default)]
1223pub struct LayerAccessGranted {
1224 #[serde(
1229 rename = "layer",
1230 skip_serializing_if = "::buffa::json_helpers::skip_if::is_unset_message_field"
1231 )]
1232 pub layer: ::buffa::MessageField<super::super::v1::Layer>,
1233 #[serde(skip)]
1234 #[doc(hidden)]
1235 pub __buffa_unknown_fields: ::buffa::UnknownFields,
1236}
1237impl ::core::fmt::Debug for LayerAccessGranted {
1238 fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
1239 f.debug_struct("LayerAccessGranted").field("layer", &self.layer).finish()
1240 }
1241}
1242impl LayerAccessGranted {
1243 pub const TYPE_URL: &'static str = "type.googleapis.com/polychart.events.v1.LayerAccessGranted";
1248}
1249::buffa::impl_default_instance!(LayerAccessGranted);
1250impl ::buffa::MessageName for LayerAccessGranted {
1251 const PACKAGE: &'static str = "polychart.events.v1";
1252 const NAME: &'static str = "LayerAccessGranted";
1253 const FULL_NAME: &'static str = "polychart.events.v1.LayerAccessGranted";
1254 const TYPE_URL: &'static str = "type.googleapis.com/polychart.events.v1.LayerAccessGranted";
1255}
1256impl ::buffa::Message for LayerAccessGranted {
1257 #[allow(clippy::let_and_return)]
1263 fn compute_size(&self, __cache: &mut ::buffa::SizeCache) -> u32 {
1264 #[allow(unused_imports)]
1265 use ::buffa::Enumeration as _;
1266 let mut size = 0u32;
1267 if self.layer.is_set() {
1268 let __slot = __cache.reserve();
1269 let inner_size = self.layer.compute_size(__cache);
1270 __cache.set(__slot, inner_size);
1271 size
1272 += 1u32 + ::buffa::encoding::varint_len(inner_size as u64) as u32
1273 + inner_size;
1274 }
1275 size += self.__buffa_unknown_fields.encoded_len() as u32;
1276 size
1277 }
1278 fn write_to(
1279 &self,
1280 __cache: &mut ::buffa::SizeCache,
1281 buf: &mut impl ::buffa::bytes::BufMut,
1282 ) {
1283 #[allow(unused_imports)]
1284 use ::buffa::Enumeration as _;
1285 if self.layer.is_set() {
1286 ::buffa::types::put_len_delimited_header(1u32, __cache.consume_next(), buf);
1287 self.layer.write_to(__cache, buf);
1288 }
1289 self.__buffa_unknown_fields.write_to(buf);
1290 }
1291 fn merge_field(
1292 &mut self,
1293 tag: ::buffa::encoding::Tag,
1294 buf: &mut impl ::buffa::bytes::Buf,
1295 ctx: ::buffa::DecodeContext<'_>,
1296 ) -> ::core::result::Result<(), ::buffa::DecodeError> {
1297 #[allow(unused_imports)]
1298 use ::buffa::bytes::Buf as _;
1299 #[allow(unused_imports)]
1300 use ::buffa::Enumeration as _;
1301 match tag.field_number() {
1302 1u32 => {
1303 ::buffa::encoding::check_wire_type(
1304 tag,
1305 ::buffa::encoding::WireType::LengthDelimited,
1306 )?;
1307 ::buffa::Message::merge_length_delimited(
1308 self.layer.get_or_insert_default(),
1309 buf,
1310 ctx,
1311 )?;
1312 }
1313 _ => {
1314 self.__buffa_unknown_fields
1315 .push(::buffa::encoding::decode_unknown_field(tag, buf, ctx)?);
1316 }
1317 }
1318 ::core::result::Result::Ok(())
1319 }
1320 fn clear(&mut self) {
1321 self.layer = ::buffa::MessageField::none();
1322 self.__buffa_unknown_fields.clear();
1323 }
1324}
1325impl ::buffa::ExtensionSet for LayerAccessGranted {
1326 const PROTO_FQN: &'static str = "polychart.events.v1.LayerAccessGranted";
1327 fn unknown_fields(&self) -> &::buffa::UnknownFields {
1328 &self.__buffa_unknown_fields
1329 }
1330 fn unknown_fields_mut(&mut self) -> &mut ::buffa::UnknownFields {
1331 &mut self.__buffa_unknown_fields
1332 }
1333}
1334impl ::buffa::json_helpers::ProtoElemJson for LayerAccessGranted {
1335 fn serialize_proto_json<S: ::serde::Serializer>(
1336 v: &Self,
1337 s: S,
1338 ) -> ::core::result::Result<S::Ok, S::Error> {
1339 ::serde::Serialize::serialize(v, s)
1340 }
1341 fn deserialize_proto_json<'de, D: ::serde::Deserializer<'de>>(
1342 d: D,
1343 ) -> ::core::result::Result<Self, D::Error> {
1344 <Self as ::serde::Deserialize>::deserialize(d)
1345 }
1346}
1347#[doc(hidden)]
1348pub const __LAYER_ACCESS_GRANTED_JSON_ANY: ::buffa::type_registry::JsonAnyEntry = ::buffa::type_registry::JsonAnyEntry {
1349 type_url: "type.googleapis.com/polychart.events.v1.LayerAccessGranted",
1350 to_json: ::buffa::type_registry::any_to_json::<LayerAccessGranted>,
1351 from_json: ::buffa::type_registry::any_from_json::<LayerAccessGranted>,
1352 is_wkt: false,
1353};
1354#[derive(Clone, PartialEq, Default)]
1355#[derive(::serde::Serialize, ::serde::Deserialize)]
1356#[serde(default)]
1357pub struct LayerAccessRevoked {
1358 #[serde(
1362 rename = "layer",
1363 skip_serializing_if = "::buffa::json_helpers::skip_if::is_unset_message_field"
1364 )]
1365 pub layer: ::buffa::MessageField<super::super::v1::LayerRef>,
1366 #[serde(
1368 rename = "engineSymbolId",
1369 alias = "engine_symbol_id",
1370 with = "::buffa::json_helpers::uint32",
1371 skip_serializing_if = "::buffa::json_helpers::skip_if::is_zero_u32"
1372 )]
1373 pub engine_symbol_id: u32,
1374 #[serde(skip)]
1375 #[doc(hidden)]
1376 pub __buffa_unknown_fields: ::buffa::UnknownFields,
1377}
1378impl ::core::fmt::Debug for LayerAccessRevoked {
1379 fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
1380 f.debug_struct("LayerAccessRevoked")
1381 .field("layer", &self.layer)
1382 .field("engine_symbol_id", &self.engine_symbol_id)
1383 .finish()
1384 }
1385}
1386impl LayerAccessRevoked {
1387 pub const TYPE_URL: &'static str = "type.googleapis.com/polychart.events.v1.LayerAccessRevoked";
1392}
1393::buffa::impl_default_instance!(LayerAccessRevoked);
1394impl ::buffa::MessageName for LayerAccessRevoked {
1395 const PACKAGE: &'static str = "polychart.events.v1";
1396 const NAME: &'static str = "LayerAccessRevoked";
1397 const FULL_NAME: &'static str = "polychart.events.v1.LayerAccessRevoked";
1398 const TYPE_URL: &'static str = "type.googleapis.com/polychart.events.v1.LayerAccessRevoked";
1399}
1400impl ::buffa::Message for LayerAccessRevoked {
1401 #[allow(clippy::let_and_return)]
1407 fn compute_size(&self, __cache: &mut ::buffa::SizeCache) -> u32 {
1408 #[allow(unused_imports)]
1409 use ::buffa::Enumeration as _;
1410 let mut size = 0u32;
1411 if self.layer.is_set() {
1412 let __slot = __cache.reserve();
1413 let inner_size = self.layer.compute_size(__cache);
1414 __cache.set(__slot, inner_size);
1415 size
1416 += 1u32 + ::buffa::encoding::varint_len(inner_size as u64) as u32
1417 + inner_size;
1418 }
1419 if self.engine_symbol_id != 0u32 {
1420 size
1421 += 1u32
1422 + ::buffa::types::uint32_encoded_len(self.engine_symbol_id) as u32;
1423 }
1424 size += self.__buffa_unknown_fields.encoded_len() as u32;
1425 size
1426 }
1427 fn write_to(
1428 &self,
1429 __cache: &mut ::buffa::SizeCache,
1430 buf: &mut impl ::buffa::bytes::BufMut,
1431 ) {
1432 #[allow(unused_imports)]
1433 use ::buffa::Enumeration as _;
1434 if self.layer.is_set() {
1435 ::buffa::types::put_len_delimited_header(1u32, __cache.consume_next(), buf);
1436 self.layer.write_to(__cache, buf);
1437 }
1438 if self.engine_symbol_id != 0u32 {
1439 ::buffa::types::put_uint32_field(2u32, self.engine_symbol_id, buf);
1440 }
1441 self.__buffa_unknown_fields.write_to(buf);
1442 }
1443 fn merge_field(
1444 &mut self,
1445 tag: ::buffa::encoding::Tag,
1446 buf: &mut impl ::buffa::bytes::Buf,
1447 ctx: ::buffa::DecodeContext<'_>,
1448 ) -> ::core::result::Result<(), ::buffa::DecodeError> {
1449 #[allow(unused_imports)]
1450 use ::buffa::bytes::Buf as _;
1451 #[allow(unused_imports)]
1452 use ::buffa::Enumeration as _;
1453 match tag.field_number() {
1454 1u32 => {
1455 ::buffa::encoding::check_wire_type(
1456 tag,
1457 ::buffa::encoding::WireType::LengthDelimited,
1458 )?;
1459 ::buffa::Message::merge_length_delimited(
1460 self.layer.get_or_insert_default(),
1461 buf,
1462 ctx,
1463 )?;
1464 }
1465 2u32 => {
1466 ::buffa::encoding::check_wire_type(
1467 tag,
1468 ::buffa::encoding::WireType::Varint,
1469 )?;
1470 self.engine_symbol_id = ::buffa::types::decode_uint32(buf)?;
1471 }
1472 _ => {
1473 self.__buffa_unknown_fields
1474 .push(::buffa::encoding::decode_unknown_field(tag, buf, ctx)?);
1475 }
1476 }
1477 ::core::result::Result::Ok(())
1478 }
1479 fn clear(&mut self) {
1480 self.layer = ::buffa::MessageField::none();
1481 self.engine_symbol_id = 0u32;
1482 self.__buffa_unknown_fields.clear();
1483 }
1484}
1485impl ::buffa::ExtensionSet for LayerAccessRevoked {
1486 const PROTO_FQN: &'static str = "polychart.events.v1.LayerAccessRevoked";
1487 fn unknown_fields(&self) -> &::buffa::UnknownFields {
1488 &self.__buffa_unknown_fields
1489 }
1490 fn unknown_fields_mut(&mut self) -> &mut ::buffa::UnknownFields {
1491 &mut self.__buffa_unknown_fields
1492 }
1493}
1494impl ::buffa::json_helpers::ProtoElemJson for LayerAccessRevoked {
1495 fn serialize_proto_json<S: ::serde::Serializer>(
1496 v: &Self,
1497 s: S,
1498 ) -> ::core::result::Result<S::Ok, S::Error> {
1499 ::serde::Serialize::serialize(v, s)
1500 }
1501 fn deserialize_proto_json<'de, D: ::serde::Deserializer<'de>>(
1502 d: D,
1503 ) -> ::core::result::Result<Self, D::Error> {
1504 <Self as ::serde::Deserialize>::deserialize(d)
1505 }
1506}
1507#[doc(hidden)]
1508pub const __LAYER_ACCESS_REVOKED_JSON_ANY: ::buffa::type_registry::JsonAnyEntry = ::buffa::type_registry::JsonAnyEntry {
1509 type_url: "type.googleapis.com/polychart.events.v1.LayerAccessRevoked",
1510 to_json: ::buffa::type_registry::any_to_json::<LayerAccessRevoked>,
1511 from_json: ::buffa::type_registry::any_from_json::<LayerAccessRevoked>,
1512 is_wkt: false,
1513};
1514#[allow(
1515 non_camel_case_types,
1516 dead_code,
1517 unused_imports,
1518 unused_qualifications,
1519 clippy::derivable_impls,
1520 clippy::match_single_binding,
1521 clippy::uninlined_format_args,
1522 clippy::doc_lazy_continuation,
1523 clippy::module_inception
1524)]
1525pub mod __buffa {
1526 #[allow(unused_imports)]
1527 use super::*;
1528 pub mod view {
1529 #[allow(unused_imports)]
1530 use super::*;
1531 #[derive(Clone, Debug, Default)]
1536 pub struct PolychartEventEnvelopeView<'a> {
1537 pub server_ts_ms: u64,
1539 pub event: ::core::option::Option<
1540 super::super::__buffa::view::oneof::polychart_event_envelope::Event<'a>,
1541 >,
1542 pub __buffa_unknown_fields: ::buffa::UnknownFieldsView<'a>,
1543 }
1544 impl<'a> ::buffa::MessageView<'a> for PolychartEventEnvelopeView<'a> {
1545 type Owned = super::super::PolychartEventEnvelope;
1546 fn decode_view(
1547 buf: &'a [u8],
1548 ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
1549 let __limit = ::core::cell::Cell::new(
1550 ::buffa::DEFAULT_UNKNOWN_FIELD_LIMIT,
1551 );
1552 <Self as ::buffa::MessageView>::decode_view_ctx(
1553 buf,
1554 ::buffa::DecodeContext::new(::buffa::RECURSION_LIMIT, &__limit),
1555 )
1556 }
1557 fn decode_view_with_ctx(
1558 buf: &'a [u8],
1559 ctx: ::buffa::DecodeContext<'_>,
1560 ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
1561 <Self as ::buffa::MessageView>::decode_view_ctx(buf, ctx)
1562 }
1563 fn merge_view_field(
1564 &mut self,
1565 tag: ::buffa::encoding::Tag,
1566 cur: &'a [u8],
1567 before_tag: &'a [u8],
1568 ctx: ::buffa::DecodeContext<'_>,
1569 ) -> ::core::result::Result<&'a [u8], ::buffa::DecodeError> {
1570 let _ = ctx;
1571 #[allow(unused_variables)]
1572 let view = self;
1573 let mut cur = cur;
1574 match tag.field_number() {
1575 1u32 => {
1576 ::buffa::encoding::check_wire_type(
1577 tag,
1578 ::buffa::encoding::WireType::Fixed64,
1579 )?;
1580 view.server_ts_ms = ::buffa::types::decode_fixed64(&mut cur)?;
1581 }
1582 10u32 => {
1583 ::buffa::encoding::check_wire_type(
1584 tag,
1585 ::buffa::encoding::WireType::LengthDelimited,
1586 )?;
1587 let __sub_ctx = ctx.descend()?;
1588 let sub = ::buffa::types::borrow_bytes(&mut cur)?;
1589 if let Some(
1590 super::super::__buffa::view::oneof::polychart_event_envelope::Event::DrawingCommitted(
1591 ref mut existing,
1592 ),
1593 ) = view.event
1594 {
1595 ::buffa::MessageView::merge_into_view(
1596 &mut **existing,
1597 sub,
1598 __sub_ctx,
1599 )?;
1600 } else {
1601 view.event = Some(
1602 super::super::__buffa::view::oneof::polychart_event_envelope::Event::DrawingCommitted(
1603 ::buffa::alloc::boxed::Box::new(
1604 <super::super::__buffa::view::DrawingCommittedView as ::buffa::MessageView>::decode_view_ctx(
1605 sub,
1606 __sub_ctx,
1607 )?,
1608 ),
1609 ),
1610 );
1611 }
1612 }
1613 11u32 => {
1614 ::buffa::encoding::check_wire_type(
1615 tag,
1616 ::buffa::encoding::WireType::LengthDelimited,
1617 )?;
1618 let __sub_ctx = ctx.descend()?;
1619 let sub = ::buffa::types::borrow_bytes(&mut cur)?;
1620 if let Some(
1621 super::super::__buffa::view::oneof::polychart_event_envelope::Event::DrawingDeleted(
1622 ref mut existing,
1623 ),
1624 ) = view.event
1625 {
1626 ::buffa::MessageView::merge_into_view(
1627 &mut **existing,
1628 sub,
1629 __sub_ctx,
1630 )?;
1631 } else {
1632 view.event = Some(
1633 super::super::__buffa::view::oneof::polychart_event_envelope::Event::DrawingDeleted(
1634 ::buffa::alloc::boxed::Box::new(
1635 <super::super::__buffa::view::DrawingDeletedView as ::buffa::MessageView>::decode_view_ctx(
1636 sub,
1637 __sub_ctx,
1638 )?,
1639 ),
1640 ),
1641 );
1642 }
1643 }
1644 20u32 => {
1645 ::buffa::encoding::check_wire_type(
1646 tag,
1647 ::buffa::encoding::WireType::LengthDelimited,
1648 )?;
1649 let __sub_ctx = ctx.descend()?;
1650 let sub = ::buffa::types::borrow_bytes(&mut cur)?;
1651 if let Some(
1652 super::super::__buffa::view::oneof::polychart_event_envelope::Event::LayerUpdated(
1653 ref mut existing,
1654 ),
1655 ) = view.event
1656 {
1657 ::buffa::MessageView::merge_into_view(
1658 &mut **existing,
1659 sub,
1660 __sub_ctx,
1661 )?;
1662 } else {
1663 view.event = Some(
1664 super::super::__buffa::view::oneof::polychart_event_envelope::Event::LayerUpdated(
1665 ::buffa::alloc::boxed::Box::new(
1666 <super::super::__buffa::view::LayerUpdatedView as ::buffa::MessageView>::decode_view_ctx(
1667 sub,
1668 __sub_ctx,
1669 )?,
1670 ),
1671 ),
1672 );
1673 }
1674 }
1675 21u32 => {
1676 ::buffa::encoding::check_wire_type(
1677 tag,
1678 ::buffa::encoding::WireType::LengthDelimited,
1679 )?;
1680 let __sub_ctx = ctx.descend()?;
1681 let sub = ::buffa::types::borrow_bytes(&mut cur)?;
1682 if let Some(
1683 super::super::__buffa::view::oneof::polychart_event_envelope::Event::LayerDeleted(
1684 ref mut existing,
1685 ),
1686 ) = view.event
1687 {
1688 ::buffa::MessageView::merge_into_view(
1689 &mut **existing,
1690 sub,
1691 __sub_ctx,
1692 )?;
1693 } else {
1694 view.event = Some(
1695 super::super::__buffa::view::oneof::polychart_event_envelope::Event::LayerDeleted(
1696 ::buffa::alloc::boxed::Box::new(
1697 <super::super::__buffa::view::LayerDeletedView as ::buffa::MessageView>::decode_view_ctx(
1698 sub,
1699 __sub_ctx,
1700 )?,
1701 ),
1702 ),
1703 );
1704 }
1705 }
1706 30u32 => {
1707 ::buffa::encoding::check_wire_type(
1708 tag,
1709 ::buffa::encoding::WireType::LengthDelimited,
1710 )?;
1711 let __sub_ctx = ctx.descend()?;
1712 let sub = ::buffa::types::borrow_bytes(&mut cur)?;
1713 if let Some(
1714 super::super::__buffa::view::oneof::polychart_event_envelope::Event::LayerAccessGranted(
1715 ref mut existing,
1716 ),
1717 ) = view.event
1718 {
1719 ::buffa::MessageView::merge_into_view(
1720 &mut **existing,
1721 sub,
1722 __sub_ctx,
1723 )?;
1724 } else {
1725 view.event = Some(
1726 super::super::__buffa::view::oneof::polychart_event_envelope::Event::LayerAccessGranted(
1727 ::buffa::alloc::boxed::Box::new(
1728 <super::super::__buffa::view::LayerAccessGrantedView as ::buffa::MessageView>::decode_view_ctx(
1729 sub,
1730 __sub_ctx,
1731 )?,
1732 ),
1733 ),
1734 );
1735 }
1736 }
1737 31u32 => {
1738 ::buffa::encoding::check_wire_type(
1739 tag,
1740 ::buffa::encoding::WireType::LengthDelimited,
1741 )?;
1742 let __sub_ctx = ctx.descend()?;
1743 let sub = ::buffa::types::borrow_bytes(&mut cur)?;
1744 if let Some(
1745 super::super::__buffa::view::oneof::polychart_event_envelope::Event::LayerAccessRevoked(
1746 ref mut existing,
1747 ),
1748 ) = view.event
1749 {
1750 ::buffa::MessageView::merge_into_view(
1751 &mut **existing,
1752 sub,
1753 __sub_ctx,
1754 )?;
1755 } else {
1756 view.event = Some(
1757 super::super::__buffa::view::oneof::polychart_event_envelope::Event::LayerAccessRevoked(
1758 ::buffa::alloc::boxed::Box::new(
1759 <super::super::__buffa::view::LayerAccessRevokedView as ::buffa::MessageView>::decode_view_ctx(
1760 sub,
1761 __sub_ctx,
1762 )?,
1763 ),
1764 ),
1765 );
1766 }
1767 }
1768 _ => {
1769 ::buffa::encoding::skip_field_depth(tag, &mut cur, ctx.depth())?;
1770 let span_len = before_tag.len() - cur.len();
1771 view.__buffa_unknown_fields
1772 .push_record(before_tag, span_len, ctx)?;
1773 }
1774 }
1775 ::core::result::Result::Ok(cur)
1776 }
1777 fn to_owned_message(
1778 &self,
1779 ) -> ::core::result::Result<
1780 super::super::PolychartEventEnvelope,
1781 ::buffa::DecodeError,
1782 > {
1783 self.to_owned_from_source(None)
1784 }
1785 #[allow(clippy::useless_conversion, clippy::needless_update)]
1786 fn to_owned_from_source(
1787 &self,
1788 __buffa_src: ::core::option::Option<&::buffa::bytes::Bytes>,
1789 ) -> ::core::result::Result<
1790 super::super::PolychartEventEnvelope,
1791 ::buffa::DecodeError,
1792 > {
1793 #[allow(unused_imports)]
1794 use ::buffa::alloc::string::ToString as _;
1795 let _ = __buffa_src;
1796 ::core::result::Result::Ok(super::super::PolychartEventEnvelope {
1797 server_ts_ms: self.server_ts_ms,
1798 event: match self.event.as_ref() {
1799 ::core::option::Option::Some(v) => {
1800 ::core::option::Option::Some(
1801 match v {
1802 super::super::__buffa::view::oneof::polychart_event_envelope::Event::DrawingCommitted(
1803 v,
1804 ) => {
1805 super::super::__buffa::oneof::polychart_event_envelope::Event::DrawingCommitted(
1806 ::buffa::alloc::boxed::Box::new(
1807 v.to_owned_from_source(__buffa_src)?,
1808 ),
1809 )
1810 }
1811 super::super::__buffa::view::oneof::polychart_event_envelope::Event::DrawingDeleted(
1812 v,
1813 ) => {
1814 super::super::__buffa::oneof::polychart_event_envelope::Event::DrawingDeleted(
1815 ::buffa::alloc::boxed::Box::new(
1816 v.to_owned_from_source(__buffa_src)?,
1817 ),
1818 )
1819 }
1820 super::super::__buffa::view::oneof::polychart_event_envelope::Event::LayerUpdated(
1821 v,
1822 ) => {
1823 super::super::__buffa::oneof::polychart_event_envelope::Event::LayerUpdated(
1824 ::buffa::alloc::boxed::Box::new(
1825 v.to_owned_from_source(__buffa_src)?,
1826 ),
1827 )
1828 }
1829 super::super::__buffa::view::oneof::polychart_event_envelope::Event::LayerDeleted(
1830 v,
1831 ) => {
1832 super::super::__buffa::oneof::polychart_event_envelope::Event::LayerDeleted(
1833 ::buffa::alloc::boxed::Box::new(
1834 v.to_owned_from_source(__buffa_src)?,
1835 ),
1836 )
1837 }
1838 super::super::__buffa::view::oneof::polychart_event_envelope::Event::LayerAccessGranted(
1839 v,
1840 ) => {
1841 super::super::__buffa::oneof::polychart_event_envelope::Event::LayerAccessGranted(
1842 ::buffa::alloc::boxed::Box::new(
1843 v.to_owned_from_source(__buffa_src)?,
1844 ),
1845 )
1846 }
1847 super::super::__buffa::view::oneof::polychart_event_envelope::Event::LayerAccessRevoked(
1848 v,
1849 ) => {
1850 super::super::__buffa::oneof::polychart_event_envelope::Event::LayerAccessRevoked(
1851 ::buffa::alloc::boxed::Box::new(
1852 v.to_owned_from_source(__buffa_src)?,
1853 ),
1854 )
1855 }
1856 },
1857 )
1858 }
1859 ::core::option::Option::None => ::core::option::Option::None,
1860 },
1861 __buffa_unknown_fields: self
1862 .__buffa_unknown_fields
1863 .to_owned()?
1864 .into(),
1865 ..::core::default::Default::default()
1866 })
1867 }
1868 }
1869 impl<'a> ::buffa::ViewEncode<'a> for PolychartEventEnvelopeView<'a> {
1870 #[allow(clippy::needless_borrow, clippy::let_and_return)]
1871 fn compute_size(&self, __cache: &mut ::buffa::SizeCache) -> u32 {
1872 #[allow(unused_imports)]
1873 use ::buffa::Enumeration as _;
1874 let mut size = 0u32;
1875 if self.server_ts_ms != 0u64 {
1876 size += 1u32 + ::buffa::types::FIXED64_ENCODED_LEN as u32;
1877 }
1878 if let ::core::option::Option::Some(ref v) = self.event {
1879 match v {
1880 super::super::__buffa::view::oneof::polychart_event_envelope::Event::DrawingCommitted(
1881 x,
1882 ) => {
1883 let __slot = __cache.reserve();
1884 let inner = x.compute_size(__cache);
1885 __cache.set(__slot, inner);
1886 size
1887 += 1u32 + ::buffa::encoding::varint_len(inner as u64) as u32
1888 + inner;
1889 }
1890 super::super::__buffa::view::oneof::polychart_event_envelope::Event::DrawingDeleted(
1891 x,
1892 ) => {
1893 let __slot = __cache.reserve();
1894 let inner = x.compute_size(__cache);
1895 __cache.set(__slot, inner);
1896 size
1897 += 1u32 + ::buffa::encoding::varint_len(inner as u64) as u32
1898 + inner;
1899 }
1900 super::super::__buffa::view::oneof::polychart_event_envelope::Event::LayerUpdated(
1901 x,
1902 ) => {
1903 let __slot = __cache.reserve();
1904 let inner = x.compute_size(__cache);
1905 __cache.set(__slot, inner);
1906 size
1907 += 2u32 + ::buffa::encoding::varint_len(inner as u64) as u32
1908 + inner;
1909 }
1910 super::super::__buffa::view::oneof::polychart_event_envelope::Event::LayerDeleted(
1911 x,
1912 ) => {
1913 let __slot = __cache.reserve();
1914 let inner = x.compute_size(__cache);
1915 __cache.set(__slot, inner);
1916 size
1917 += 2u32 + ::buffa::encoding::varint_len(inner as u64) as u32
1918 + inner;
1919 }
1920 super::super::__buffa::view::oneof::polychart_event_envelope::Event::LayerAccessGranted(
1921 x,
1922 ) => {
1923 let __slot = __cache.reserve();
1924 let inner = x.compute_size(__cache);
1925 __cache.set(__slot, inner);
1926 size
1927 += 2u32 + ::buffa::encoding::varint_len(inner as u64) as u32
1928 + inner;
1929 }
1930 super::super::__buffa::view::oneof::polychart_event_envelope::Event::LayerAccessRevoked(
1931 x,
1932 ) => {
1933 let __slot = __cache.reserve();
1934 let inner = x.compute_size(__cache);
1935 __cache.set(__slot, inner);
1936 size
1937 += 2u32 + ::buffa::encoding::varint_len(inner as u64) as u32
1938 + inner;
1939 }
1940 }
1941 }
1942 size += self.__buffa_unknown_fields.encoded_len() as u32;
1943 size
1944 }
1945 #[allow(clippy::needless_borrow)]
1946 fn write_to(
1947 &self,
1948 __cache: &mut ::buffa::SizeCache,
1949 buf: &mut impl ::buffa::bytes::BufMut,
1950 ) {
1951 #[allow(unused_imports)]
1952 use ::buffa::Enumeration as _;
1953 if self.server_ts_ms != 0u64 {
1954 ::buffa::types::put_fixed64_field(1u32, self.server_ts_ms, buf);
1955 }
1956 if let ::core::option::Option::Some(ref v) = self.event {
1957 match v {
1958 super::super::__buffa::view::oneof::polychart_event_envelope::Event::DrawingCommitted(
1959 x,
1960 ) => {
1961 ::buffa::types::put_len_delimited_header(
1962 10u32,
1963 __cache.consume_next(),
1964 buf,
1965 );
1966 x.write_to(__cache, buf);
1967 }
1968 super::super::__buffa::view::oneof::polychart_event_envelope::Event::DrawingDeleted(
1969 x,
1970 ) => {
1971 ::buffa::types::put_len_delimited_header(
1972 11u32,
1973 __cache.consume_next(),
1974 buf,
1975 );
1976 x.write_to(__cache, buf);
1977 }
1978 super::super::__buffa::view::oneof::polychart_event_envelope::Event::LayerUpdated(
1979 x,
1980 ) => {
1981 ::buffa::types::put_len_delimited_header(
1982 20u32,
1983 __cache.consume_next(),
1984 buf,
1985 );
1986 x.write_to(__cache, buf);
1987 }
1988 super::super::__buffa::view::oneof::polychart_event_envelope::Event::LayerDeleted(
1989 x,
1990 ) => {
1991 ::buffa::types::put_len_delimited_header(
1992 21u32,
1993 __cache.consume_next(),
1994 buf,
1995 );
1996 x.write_to(__cache, buf);
1997 }
1998 super::super::__buffa::view::oneof::polychart_event_envelope::Event::LayerAccessGranted(
1999 x,
2000 ) => {
2001 ::buffa::types::put_len_delimited_header(
2002 30u32,
2003 __cache.consume_next(),
2004 buf,
2005 );
2006 x.write_to(__cache, buf);
2007 }
2008 super::super::__buffa::view::oneof::polychart_event_envelope::Event::LayerAccessRevoked(
2009 x,
2010 ) => {
2011 ::buffa::types::put_len_delimited_header(
2012 31u32,
2013 __cache.consume_next(),
2014 buf,
2015 );
2016 x.write_to(__cache, buf);
2017 }
2018 }
2019 }
2020 self.__buffa_unknown_fields.write_to(buf);
2021 }
2022 }
2023 impl<'__a> ::serde::Serialize for PolychartEventEnvelopeView<'__a> {
2035 fn serialize<__S: ::serde::Serializer>(
2036 &self,
2037 __s: __S,
2038 ) -> ::core::result::Result<__S::Ok, __S::Error> {
2039 use ::serde::ser::SerializeMap as _;
2040 let mut __map = __s.serialize_map(::core::option::Option::None)?;
2041 if !::buffa::json_helpers::skip_if::is_zero_u64(&self.server_ts_ms) {
2042 __map
2043 .serialize_entry(
2044 "serverTsMs",
2045 &::buffa::json_helpers::ProtoJson(&self.server_ts_ms),
2046 )?;
2047 }
2048 if let ::core::option::Option::Some(ref __ov) = self.event {
2049 match __ov {
2050 super::super::__buffa::view::oneof::polychart_event_envelope::Event::DrawingCommitted(
2051 v,
2052 ) => {
2053 __map.serialize_entry("drawingCommitted", v)?;
2054 }
2055 super::super::__buffa::view::oneof::polychart_event_envelope::Event::DrawingDeleted(
2056 v,
2057 ) => {
2058 __map.serialize_entry("drawingDeleted", v)?;
2059 }
2060 super::super::__buffa::view::oneof::polychart_event_envelope::Event::LayerUpdated(
2061 v,
2062 ) => {
2063 __map.serialize_entry("layerUpdated", v)?;
2064 }
2065 super::super::__buffa::view::oneof::polychart_event_envelope::Event::LayerDeleted(
2066 v,
2067 ) => {
2068 __map.serialize_entry("layerDeleted", v)?;
2069 }
2070 super::super::__buffa::view::oneof::polychart_event_envelope::Event::LayerAccessGranted(
2071 v,
2072 ) => {
2073 __map.serialize_entry("layerAccessGranted", v)?;
2074 }
2075 super::super::__buffa::view::oneof::polychart_event_envelope::Event::LayerAccessRevoked(
2076 v,
2077 ) => {
2078 __map.serialize_entry("layerAccessRevoked", v)?;
2079 }
2080 }
2081 }
2082 __map.end()
2083 }
2084 }
2085 impl<'a> ::buffa::MessageName for PolychartEventEnvelopeView<'a> {
2086 const PACKAGE: &'static str = "polychart.events.v1";
2087 const NAME: &'static str = "PolychartEventEnvelope";
2088 const FULL_NAME: &'static str = "polychart.events.v1.PolychartEventEnvelope";
2089 const TYPE_URL: &'static str = "type.googleapis.com/polychart.events.v1.PolychartEventEnvelope";
2090 }
2091 ::buffa::impl_default_view_instance!(PolychartEventEnvelopeView);
2092 ::buffa::impl_view_reborrow!(PolychartEventEnvelopeView);
2093 #[derive(Clone, Debug)]
2099 pub struct PolychartEventEnvelopeOwnedView(
2100 ::buffa::OwnedView<PolychartEventEnvelopeView<'static>>,
2101 );
2102 impl PolychartEventEnvelopeOwnedView {
2103 pub fn decode(
2113 bytes: ::buffa::bytes::Bytes,
2114 ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
2115 ::core::result::Result::Ok(
2116 PolychartEventEnvelopeOwnedView(::buffa::OwnedView::decode(bytes)?),
2117 )
2118 }
2119 pub fn decode_with_options(
2127 bytes: ::buffa::bytes::Bytes,
2128 opts: &::buffa::DecodeOptions,
2129 ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
2130 ::core::result::Result::Ok(
2131 PolychartEventEnvelopeOwnedView(
2132 ::buffa::OwnedView::decode_with_options(bytes, opts)?,
2133 ),
2134 )
2135 }
2136 pub fn from_owned(
2143 msg: &super::super::PolychartEventEnvelope,
2144 ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
2145 ::core::result::Result::Ok(
2146 PolychartEventEnvelopeOwnedView(::buffa::OwnedView::from_owned(msg)?),
2147 )
2148 }
2149 #[must_use]
2151 pub fn view(&self) -> &PolychartEventEnvelopeView<'_> {
2152 self.0.reborrow()
2153 }
2154 pub fn to_owned_message(
2161 &self,
2162 ) -> ::core::result::Result<
2163 super::super::PolychartEventEnvelope,
2164 ::buffa::DecodeError,
2165 > {
2166 self.0.to_owned_message()
2167 }
2168 #[must_use]
2170 pub fn bytes(&self) -> &::buffa::bytes::Bytes {
2171 self.0.bytes()
2172 }
2173 #[must_use]
2175 pub fn into_bytes(self) -> ::buffa::bytes::Bytes {
2176 self.0.into_bytes()
2177 }
2178 #[must_use]
2180 pub fn server_ts_ms(&self) -> u64 {
2181 self.0.reborrow().server_ts_ms
2182 }
2183 #[must_use]
2185 pub fn event(
2186 &self,
2187 ) -> ::core::option::Option<
2188 &super::super::__buffa::view::oneof::polychart_event_envelope::Event<'_>,
2189 > {
2190 self.0.reborrow().event.as_ref()
2191 }
2192 }
2193 impl ::core::convert::From<
2194 ::buffa::OwnedView<PolychartEventEnvelopeView<'static>>,
2195 > for PolychartEventEnvelopeOwnedView {
2196 fn from(
2197 inner: ::buffa::OwnedView<PolychartEventEnvelopeView<'static>>,
2198 ) -> Self {
2199 PolychartEventEnvelopeOwnedView(inner)
2200 }
2201 }
2202 impl ::core::convert::From<PolychartEventEnvelopeOwnedView>
2203 for ::buffa::OwnedView<PolychartEventEnvelopeView<'static>> {
2204 fn from(wrapper: PolychartEventEnvelopeOwnedView) -> Self {
2205 wrapper.0
2206 }
2207 }
2208 impl ::core::convert::AsRef<
2209 ::buffa::OwnedView<PolychartEventEnvelopeView<'static>>,
2210 > for PolychartEventEnvelopeOwnedView {
2211 fn as_ref(
2212 &self,
2213 ) -> &::buffa::OwnedView<PolychartEventEnvelopeView<'static>> {
2214 &self.0
2215 }
2216 }
2217 impl ::buffa::HasMessageView for super::super::PolychartEventEnvelope {
2218 type View<'a> = PolychartEventEnvelopeView<'a>;
2219 type ViewHandle = PolychartEventEnvelopeOwnedView;
2220 }
2221 impl ::serde::Serialize for PolychartEventEnvelopeOwnedView {
2222 fn serialize<__S: ::serde::Serializer>(
2223 &self,
2224 __s: __S,
2225 ) -> ::core::result::Result<__S::Ok, __S::Error> {
2226 ::serde::Serialize::serialize(&self.0, __s)
2227 }
2228 }
2229 #[derive(Clone, Debug, Default)]
2230 pub struct DrawingCommittedView<'a> {
2231 pub drawing: ::buffa::MessageFieldView<
2233 super::super::super::super::v1::__buffa::view::DrawingView<'a>,
2234 >,
2235 pub layer_revision: u64,
2239 pub __buffa_unknown_fields: ::buffa::UnknownFieldsView<'a>,
2240 }
2241 impl<'a> ::buffa::MessageView<'a> for DrawingCommittedView<'a> {
2242 type Owned = super::super::DrawingCommitted;
2243 fn decode_view(
2244 buf: &'a [u8],
2245 ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
2246 let __limit = ::core::cell::Cell::new(
2247 ::buffa::DEFAULT_UNKNOWN_FIELD_LIMIT,
2248 );
2249 <Self as ::buffa::MessageView>::decode_view_ctx(
2250 buf,
2251 ::buffa::DecodeContext::new(::buffa::RECURSION_LIMIT, &__limit),
2252 )
2253 }
2254 fn decode_view_with_ctx(
2255 buf: &'a [u8],
2256 ctx: ::buffa::DecodeContext<'_>,
2257 ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
2258 <Self as ::buffa::MessageView>::decode_view_ctx(buf, ctx)
2259 }
2260 fn merge_view_field(
2261 &mut self,
2262 tag: ::buffa::encoding::Tag,
2263 cur: &'a [u8],
2264 before_tag: &'a [u8],
2265 ctx: ::buffa::DecodeContext<'_>,
2266 ) -> ::core::result::Result<&'a [u8], ::buffa::DecodeError> {
2267 let _ = ctx;
2268 #[allow(unused_variables)]
2269 let view = self;
2270 let mut cur = cur;
2271 match tag.field_number() {
2272 1u32 => {
2273 ::buffa::encoding::check_wire_type(
2274 tag,
2275 ::buffa::encoding::WireType::LengthDelimited,
2276 )?;
2277 let __sub_ctx = ctx.descend()?;
2278 let sub = ::buffa::types::borrow_bytes(&mut cur)?;
2279 match view.drawing.as_mut() {
2280 Some(existing) => {
2281 ::buffa::MessageView::merge_into_view(
2282 existing,
2283 sub,
2284 __sub_ctx,
2285 )?
2286 }
2287 None => {
2288 view.drawing = ::buffa::MessageFieldView::set(
2289 <super::super::super::super::v1::__buffa::view::DrawingView as ::buffa::MessageView>::decode_view_ctx(
2290 sub,
2291 __sub_ctx,
2292 )?,
2293 );
2294 }
2295 }
2296 }
2297 2u32 => {
2298 ::buffa::encoding::check_wire_type(
2299 tag,
2300 ::buffa::encoding::WireType::Fixed64,
2301 )?;
2302 view.layer_revision = ::buffa::types::decode_fixed64(&mut cur)?;
2303 }
2304 _ => {
2305 ::buffa::encoding::skip_field_depth(tag, &mut cur, ctx.depth())?;
2306 let span_len = before_tag.len() - cur.len();
2307 view.__buffa_unknown_fields
2308 .push_record(before_tag, span_len, ctx)?;
2309 }
2310 }
2311 ::core::result::Result::Ok(cur)
2312 }
2313 fn to_owned_message(
2314 &self,
2315 ) -> ::core::result::Result<
2316 super::super::DrawingCommitted,
2317 ::buffa::DecodeError,
2318 > {
2319 self.to_owned_from_source(None)
2320 }
2321 #[allow(clippy::useless_conversion, clippy::needless_update)]
2322 fn to_owned_from_source(
2323 &self,
2324 __buffa_src: ::core::option::Option<&::buffa::bytes::Bytes>,
2325 ) -> ::core::result::Result<
2326 super::super::DrawingCommitted,
2327 ::buffa::DecodeError,
2328 > {
2329 #[allow(unused_imports)]
2330 use ::buffa::alloc::string::ToString as _;
2331 let _ = __buffa_src;
2332 ::core::result::Result::Ok(super::super::DrawingCommitted {
2333 drawing: match self.drawing.as_option() {
2334 Some(v) => {
2335 ::buffa::MessageField::<
2336 super::super::super::super::v1::Drawing,
2337 >::some(v.to_owned_from_source(__buffa_src)?)
2338 }
2339 None => ::buffa::MessageField::none(),
2340 },
2341 layer_revision: self.layer_revision,
2342 __buffa_unknown_fields: self
2343 .__buffa_unknown_fields
2344 .to_owned()?
2345 .into(),
2346 ..::core::default::Default::default()
2347 })
2348 }
2349 }
2350 impl<'a> ::buffa::ViewEncode<'a> for DrawingCommittedView<'a> {
2351 #[allow(clippy::needless_borrow, clippy::let_and_return)]
2352 fn compute_size(&self, __cache: &mut ::buffa::SizeCache) -> u32 {
2353 #[allow(unused_imports)]
2354 use ::buffa::Enumeration as _;
2355 let mut size = 0u32;
2356 if self.drawing.is_set() {
2357 let __slot = __cache.reserve();
2358 let inner_size = self.drawing.compute_size(__cache);
2359 __cache.set(__slot, inner_size);
2360 size
2361 += 1u32 + ::buffa::encoding::varint_len(inner_size as u64) as u32
2362 + inner_size;
2363 }
2364 if self.layer_revision != 0u64 {
2365 size += 1u32 + ::buffa::types::FIXED64_ENCODED_LEN as u32;
2366 }
2367 size += self.__buffa_unknown_fields.encoded_len() as u32;
2368 size
2369 }
2370 #[allow(clippy::needless_borrow)]
2371 fn write_to(
2372 &self,
2373 __cache: &mut ::buffa::SizeCache,
2374 buf: &mut impl ::buffa::bytes::BufMut,
2375 ) {
2376 #[allow(unused_imports)]
2377 use ::buffa::Enumeration as _;
2378 if self.drawing.is_set() {
2379 ::buffa::types::put_len_delimited_header(
2380 1u32,
2381 __cache.consume_next(),
2382 buf,
2383 );
2384 self.drawing.write_to(__cache, buf);
2385 }
2386 if self.layer_revision != 0u64 {
2387 ::buffa::types::put_fixed64_field(2u32, self.layer_revision, buf);
2388 }
2389 self.__buffa_unknown_fields.write_to(buf);
2390 }
2391 }
2392 impl<'__a> ::serde::Serialize for DrawingCommittedView<'__a> {
2404 fn serialize<__S: ::serde::Serializer>(
2405 &self,
2406 __s: __S,
2407 ) -> ::core::result::Result<__S::Ok, __S::Error> {
2408 use ::serde::ser::SerializeMap as _;
2409 let mut __map = __s.serialize_map(::core::option::Option::None)?;
2410 {
2411 if let ::core::option::Option::Some(__v) = self.drawing.as_option() {
2412 __map.serialize_entry("drawing", __v)?;
2413 }
2414 }
2415 if !::buffa::json_helpers::skip_if::is_zero_u64(&self.layer_revision) {
2416 __map
2417 .serialize_entry(
2418 "layerRevision",
2419 &::buffa::json_helpers::ProtoJson(&self.layer_revision),
2420 )?;
2421 }
2422 __map.end()
2423 }
2424 }
2425 impl<'a> ::buffa::MessageName for DrawingCommittedView<'a> {
2426 const PACKAGE: &'static str = "polychart.events.v1";
2427 const NAME: &'static str = "DrawingCommitted";
2428 const FULL_NAME: &'static str = "polychart.events.v1.DrawingCommitted";
2429 const TYPE_URL: &'static str = "type.googleapis.com/polychart.events.v1.DrawingCommitted";
2430 }
2431 ::buffa::impl_default_view_instance!(DrawingCommittedView);
2432 ::buffa::impl_view_reborrow!(DrawingCommittedView);
2433 #[derive(Clone, Debug)]
2439 pub struct DrawingCommittedOwnedView(
2440 ::buffa::OwnedView<DrawingCommittedView<'static>>,
2441 );
2442 impl DrawingCommittedOwnedView {
2443 pub fn decode(
2453 bytes: ::buffa::bytes::Bytes,
2454 ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
2455 ::core::result::Result::Ok(
2456 DrawingCommittedOwnedView(::buffa::OwnedView::decode(bytes)?),
2457 )
2458 }
2459 pub fn decode_with_options(
2467 bytes: ::buffa::bytes::Bytes,
2468 opts: &::buffa::DecodeOptions,
2469 ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
2470 ::core::result::Result::Ok(
2471 DrawingCommittedOwnedView(
2472 ::buffa::OwnedView::decode_with_options(bytes, opts)?,
2473 ),
2474 )
2475 }
2476 pub fn from_owned(
2483 msg: &super::super::DrawingCommitted,
2484 ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
2485 ::core::result::Result::Ok(
2486 DrawingCommittedOwnedView(::buffa::OwnedView::from_owned(msg)?),
2487 )
2488 }
2489 #[must_use]
2491 pub fn view(&self) -> &DrawingCommittedView<'_> {
2492 self.0.reborrow()
2493 }
2494 pub fn to_owned_message(
2501 &self,
2502 ) -> ::core::result::Result<
2503 super::super::DrawingCommitted,
2504 ::buffa::DecodeError,
2505 > {
2506 self.0.to_owned_message()
2507 }
2508 #[must_use]
2510 pub fn bytes(&self) -> &::buffa::bytes::Bytes {
2511 self.0.bytes()
2512 }
2513 #[must_use]
2515 pub fn into_bytes(self) -> ::buffa::bytes::Bytes {
2516 self.0.into_bytes()
2517 }
2518 #[must_use]
2520 pub fn drawing(
2521 &self,
2522 ) -> &::buffa::MessageFieldView<
2523 super::super::super::super::v1::__buffa::view::DrawingView<'_>,
2524 > {
2525 &self.0.reborrow().drawing
2526 }
2527 #[must_use]
2531 pub fn layer_revision(&self) -> u64 {
2532 self.0.reborrow().layer_revision
2533 }
2534 }
2535 impl ::core::convert::From<::buffa::OwnedView<DrawingCommittedView<'static>>>
2536 for DrawingCommittedOwnedView {
2537 fn from(inner: ::buffa::OwnedView<DrawingCommittedView<'static>>) -> Self {
2538 DrawingCommittedOwnedView(inner)
2539 }
2540 }
2541 impl ::core::convert::From<DrawingCommittedOwnedView>
2542 for ::buffa::OwnedView<DrawingCommittedView<'static>> {
2543 fn from(wrapper: DrawingCommittedOwnedView) -> Self {
2544 wrapper.0
2545 }
2546 }
2547 impl ::core::convert::AsRef<::buffa::OwnedView<DrawingCommittedView<'static>>>
2548 for DrawingCommittedOwnedView {
2549 fn as_ref(&self) -> &::buffa::OwnedView<DrawingCommittedView<'static>> {
2550 &self.0
2551 }
2552 }
2553 impl ::buffa::HasMessageView for super::super::DrawingCommitted {
2554 type View<'a> = DrawingCommittedView<'a>;
2555 type ViewHandle = DrawingCommittedOwnedView;
2556 }
2557 impl ::serde::Serialize for DrawingCommittedOwnedView {
2558 fn serialize<__S: ::serde::Serializer>(
2559 &self,
2560 __s: __S,
2561 ) -> ::core::result::Result<__S::Ok, __S::Error> {
2562 ::serde::Serialize::serialize(&self.0, __s)
2563 }
2564 }
2565 #[derive(Clone, Debug, Default)]
2566 pub struct DrawingDeletedView<'a> {
2567 pub drawing: ::buffa::MessageFieldView<
2569 super::super::super::super::v1::__buffa::view::DrawingRefView<'a>,
2570 >,
2571 pub layer: ::buffa::MessageFieldView<
2573 super::super::super::super::v1::__buffa::view::LayerRefView<'a>,
2574 >,
2575 pub layer_revision: u64,
2577 pub __buffa_unknown_fields: ::buffa::UnknownFieldsView<'a>,
2578 }
2579 impl<'a> ::buffa::MessageView<'a> for DrawingDeletedView<'a> {
2580 type Owned = super::super::DrawingDeleted;
2581 fn decode_view(
2582 buf: &'a [u8],
2583 ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
2584 let __limit = ::core::cell::Cell::new(
2585 ::buffa::DEFAULT_UNKNOWN_FIELD_LIMIT,
2586 );
2587 <Self as ::buffa::MessageView>::decode_view_ctx(
2588 buf,
2589 ::buffa::DecodeContext::new(::buffa::RECURSION_LIMIT, &__limit),
2590 )
2591 }
2592 fn decode_view_with_ctx(
2593 buf: &'a [u8],
2594 ctx: ::buffa::DecodeContext<'_>,
2595 ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
2596 <Self as ::buffa::MessageView>::decode_view_ctx(buf, ctx)
2597 }
2598 fn merge_view_field(
2599 &mut self,
2600 tag: ::buffa::encoding::Tag,
2601 cur: &'a [u8],
2602 before_tag: &'a [u8],
2603 ctx: ::buffa::DecodeContext<'_>,
2604 ) -> ::core::result::Result<&'a [u8], ::buffa::DecodeError> {
2605 let _ = ctx;
2606 #[allow(unused_variables)]
2607 let view = self;
2608 let mut cur = cur;
2609 match tag.field_number() {
2610 1u32 => {
2611 ::buffa::encoding::check_wire_type(
2612 tag,
2613 ::buffa::encoding::WireType::LengthDelimited,
2614 )?;
2615 let __sub_ctx = ctx.descend()?;
2616 let sub = ::buffa::types::borrow_bytes(&mut cur)?;
2617 match view.drawing.as_mut() {
2618 Some(existing) => {
2619 ::buffa::MessageView::merge_into_view(
2620 existing,
2621 sub,
2622 __sub_ctx,
2623 )?
2624 }
2625 None => {
2626 view.drawing = ::buffa::MessageFieldView::set(
2627 <super::super::super::super::v1::__buffa::view::DrawingRefView as ::buffa::MessageView>::decode_view_ctx(
2628 sub,
2629 __sub_ctx,
2630 )?,
2631 );
2632 }
2633 }
2634 }
2635 2u32 => {
2636 ::buffa::encoding::check_wire_type(
2637 tag,
2638 ::buffa::encoding::WireType::LengthDelimited,
2639 )?;
2640 let __sub_ctx = ctx.descend()?;
2641 let sub = ::buffa::types::borrow_bytes(&mut cur)?;
2642 match view.layer.as_mut() {
2643 Some(existing) => {
2644 ::buffa::MessageView::merge_into_view(
2645 existing,
2646 sub,
2647 __sub_ctx,
2648 )?
2649 }
2650 None => {
2651 view.layer = ::buffa::MessageFieldView::set(
2652 <super::super::super::super::v1::__buffa::view::LayerRefView as ::buffa::MessageView>::decode_view_ctx(
2653 sub,
2654 __sub_ctx,
2655 )?,
2656 );
2657 }
2658 }
2659 }
2660 3u32 => {
2661 ::buffa::encoding::check_wire_type(
2662 tag,
2663 ::buffa::encoding::WireType::Fixed64,
2664 )?;
2665 view.layer_revision = ::buffa::types::decode_fixed64(&mut cur)?;
2666 }
2667 _ => {
2668 ::buffa::encoding::skip_field_depth(tag, &mut cur, ctx.depth())?;
2669 let span_len = before_tag.len() - cur.len();
2670 view.__buffa_unknown_fields
2671 .push_record(before_tag, span_len, ctx)?;
2672 }
2673 }
2674 ::core::result::Result::Ok(cur)
2675 }
2676 fn to_owned_message(
2677 &self,
2678 ) -> ::core::result::Result<
2679 super::super::DrawingDeleted,
2680 ::buffa::DecodeError,
2681 > {
2682 self.to_owned_from_source(None)
2683 }
2684 #[allow(clippy::useless_conversion, clippy::needless_update)]
2685 fn to_owned_from_source(
2686 &self,
2687 __buffa_src: ::core::option::Option<&::buffa::bytes::Bytes>,
2688 ) -> ::core::result::Result<
2689 super::super::DrawingDeleted,
2690 ::buffa::DecodeError,
2691 > {
2692 #[allow(unused_imports)]
2693 use ::buffa::alloc::string::ToString as _;
2694 let _ = __buffa_src;
2695 ::core::result::Result::Ok(super::super::DrawingDeleted {
2696 drawing: match self.drawing.as_option() {
2697 Some(v) => {
2698 ::buffa::MessageField::<
2699 super::super::super::super::v1::DrawingRef,
2700 >::some(v.to_owned_from_source(__buffa_src)?)
2701 }
2702 None => ::buffa::MessageField::none(),
2703 },
2704 layer: match self.layer.as_option() {
2705 Some(v) => {
2706 ::buffa::MessageField::<
2707 super::super::super::super::v1::LayerRef,
2708 >::some(v.to_owned_from_source(__buffa_src)?)
2709 }
2710 None => ::buffa::MessageField::none(),
2711 },
2712 layer_revision: self.layer_revision,
2713 __buffa_unknown_fields: self
2714 .__buffa_unknown_fields
2715 .to_owned()?
2716 .into(),
2717 ..::core::default::Default::default()
2718 })
2719 }
2720 }
2721 impl<'a> ::buffa::ViewEncode<'a> for DrawingDeletedView<'a> {
2722 #[allow(clippy::needless_borrow, clippy::let_and_return)]
2723 fn compute_size(&self, __cache: &mut ::buffa::SizeCache) -> u32 {
2724 #[allow(unused_imports)]
2725 use ::buffa::Enumeration as _;
2726 let mut size = 0u32;
2727 if self.drawing.is_set() {
2728 let __slot = __cache.reserve();
2729 let inner_size = self.drawing.compute_size(__cache);
2730 __cache.set(__slot, inner_size);
2731 size
2732 += 1u32 + ::buffa::encoding::varint_len(inner_size as u64) as u32
2733 + inner_size;
2734 }
2735 if self.layer.is_set() {
2736 let __slot = __cache.reserve();
2737 let inner_size = self.layer.compute_size(__cache);
2738 __cache.set(__slot, inner_size);
2739 size
2740 += 1u32 + ::buffa::encoding::varint_len(inner_size as u64) as u32
2741 + inner_size;
2742 }
2743 if self.layer_revision != 0u64 {
2744 size += 1u32 + ::buffa::types::FIXED64_ENCODED_LEN as u32;
2745 }
2746 size += self.__buffa_unknown_fields.encoded_len() as u32;
2747 size
2748 }
2749 #[allow(clippy::needless_borrow)]
2750 fn write_to(
2751 &self,
2752 __cache: &mut ::buffa::SizeCache,
2753 buf: &mut impl ::buffa::bytes::BufMut,
2754 ) {
2755 #[allow(unused_imports)]
2756 use ::buffa::Enumeration as _;
2757 if self.drawing.is_set() {
2758 ::buffa::types::put_len_delimited_header(
2759 1u32,
2760 __cache.consume_next(),
2761 buf,
2762 );
2763 self.drawing.write_to(__cache, buf);
2764 }
2765 if self.layer.is_set() {
2766 ::buffa::types::put_len_delimited_header(
2767 2u32,
2768 __cache.consume_next(),
2769 buf,
2770 );
2771 self.layer.write_to(__cache, buf);
2772 }
2773 if self.layer_revision != 0u64 {
2774 ::buffa::types::put_fixed64_field(3u32, self.layer_revision, buf);
2775 }
2776 self.__buffa_unknown_fields.write_to(buf);
2777 }
2778 }
2779 impl<'__a> ::serde::Serialize for DrawingDeletedView<'__a> {
2791 fn serialize<__S: ::serde::Serializer>(
2792 &self,
2793 __s: __S,
2794 ) -> ::core::result::Result<__S::Ok, __S::Error> {
2795 use ::serde::ser::SerializeMap as _;
2796 let mut __map = __s.serialize_map(::core::option::Option::None)?;
2797 {
2798 if let ::core::option::Option::Some(__v) = self.drawing.as_option() {
2799 __map.serialize_entry("drawing", __v)?;
2800 }
2801 }
2802 {
2803 if let ::core::option::Option::Some(__v) = self.layer.as_option() {
2804 __map.serialize_entry("layer", __v)?;
2805 }
2806 }
2807 if !::buffa::json_helpers::skip_if::is_zero_u64(&self.layer_revision) {
2808 __map
2809 .serialize_entry(
2810 "layerRevision",
2811 &::buffa::json_helpers::ProtoJson(&self.layer_revision),
2812 )?;
2813 }
2814 __map.end()
2815 }
2816 }
2817 impl<'a> ::buffa::MessageName for DrawingDeletedView<'a> {
2818 const PACKAGE: &'static str = "polychart.events.v1";
2819 const NAME: &'static str = "DrawingDeleted";
2820 const FULL_NAME: &'static str = "polychart.events.v1.DrawingDeleted";
2821 const TYPE_URL: &'static str = "type.googleapis.com/polychart.events.v1.DrawingDeleted";
2822 }
2823 ::buffa::impl_default_view_instance!(DrawingDeletedView);
2824 ::buffa::impl_view_reborrow!(DrawingDeletedView);
2825 #[derive(Clone, Debug)]
2831 pub struct DrawingDeletedOwnedView(
2832 ::buffa::OwnedView<DrawingDeletedView<'static>>,
2833 );
2834 impl DrawingDeletedOwnedView {
2835 pub fn decode(
2845 bytes: ::buffa::bytes::Bytes,
2846 ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
2847 ::core::result::Result::Ok(
2848 DrawingDeletedOwnedView(::buffa::OwnedView::decode(bytes)?),
2849 )
2850 }
2851 pub fn decode_with_options(
2859 bytes: ::buffa::bytes::Bytes,
2860 opts: &::buffa::DecodeOptions,
2861 ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
2862 ::core::result::Result::Ok(
2863 DrawingDeletedOwnedView(
2864 ::buffa::OwnedView::decode_with_options(bytes, opts)?,
2865 ),
2866 )
2867 }
2868 pub fn from_owned(
2875 msg: &super::super::DrawingDeleted,
2876 ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
2877 ::core::result::Result::Ok(
2878 DrawingDeletedOwnedView(::buffa::OwnedView::from_owned(msg)?),
2879 )
2880 }
2881 #[must_use]
2883 pub fn view(&self) -> &DrawingDeletedView<'_> {
2884 self.0.reborrow()
2885 }
2886 pub fn to_owned_message(
2893 &self,
2894 ) -> ::core::result::Result<
2895 super::super::DrawingDeleted,
2896 ::buffa::DecodeError,
2897 > {
2898 self.0.to_owned_message()
2899 }
2900 #[must_use]
2902 pub fn bytes(&self) -> &::buffa::bytes::Bytes {
2903 self.0.bytes()
2904 }
2905 #[must_use]
2907 pub fn into_bytes(self) -> ::buffa::bytes::Bytes {
2908 self.0.into_bytes()
2909 }
2910 #[must_use]
2912 pub fn drawing(
2913 &self,
2914 ) -> &::buffa::MessageFieldView<
2915 super::super::super::super::v1::__buffa::view::DrawingRefView<'_>,
2916 > {
2917 &self.0.reborrow().drawing
2918 }
2919 #[must_use]
2921 pub fn layer(
2922 &self,
2923 ) -> &::buffa::MessageFieldView<
2924 super::super::super::super::v1::__buffa::view::LayerRefView<'_>,
2925 > {
2926 &self.0.reborrow().layer
2927 }
2928 #[must_use]
2930 pub fn layer_revision(&self) -> u64 {
2931 self.0.reborrow().layer_revision
2932 }
2933 }
2934 impl ::core::convert::From<::buffa::OwnedView<DrawingDeletedView<'static>>>
2935 for DrawingDeletedOwnedView {
2936 fn from(inner: ::buffa::OwnedView<DrawingDeletedView<'static>>) -> Self {
2937 DrawingDeletedOwnedView(inner)
2938 }
2939 }
2940 impl ::core::convert::From<DrawingDeletedOwnedView>
2941 for ::buffa::OwnedView<DrawingDeletedView<'static>> {
2942 fn from(wrapper: DrawingDeletedOwnedView) -> Self {
2943 wrapper.0
2944 }
2945 }
2946 impl ::core::convert::AsRef<::buffa::OwnedView<DrawingDeletedView<'static>>>
2947 for DrawingDeletedOwnedView {
2948 fn as_ref(&self) -> &::buffa::OwnedView<DrawingDeletedView<'static>> {
2949 &self.0
2950 }
2951 }
2952 impl ::buffa::HasMessageView for super::super::DrawingDeleted {
2953 type View<'a> = DrawingDeletedView<'a>;
2954 type ViewHandle = DrawingDeletedOwnedView;
2955 }
2956 impl ::serde::Serialize for DrawingDeletedOwnedView {
2957 fn serialize<__S: ::serde::Serializer>(
2958 &self,
2959 __s: __S,
2960 ) -> ::core::result::Result<__S::Ok, __S::Error> {
2961 ::serde::Serialize::serialize(&self.0, __s)
2962 }
2963 }
2964 #[derive(Clone, Debug, Default)]
2965 pub struct LayerUpdatedView<'a> {
2966 pub layer: ::buffa::MessageFieldView<
2968 super::super::super::super::v1::__buffa::view::LayerView<'a>,
2969 >,
2970 pub __buffa_unknown_fields: ::buffa::UnknownFieldsView<'a>,
2971 }
2972 impl<'a> ::buffa::MessageView<'a> for LayerUpdatedView<'a> {
2973 type Owned = super::super::LayerUpdated;
2974 fn decode_view(
2975 buf: &'a [u8],
2976 ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
2977 let __limit = ::core::cell::Cell::new(
2978 ::buffa::DEFAULT_UNKNOWN_FIELD_LIMIT,
2979 );
2980 <Self as ::buffa::MessageView>::decode_view_ctx(
2981 buf,
2982 ::buffa::DecodeContext::new(::buffa::RECURSION_LIMIT, &__limit),
2983 )
2984 }
2985 fn decode_view_with_ctx(
2986 buf: &'a [u8],
2987 ctx: ::buffa::DecodeContext<'_>,
2988 ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
2989 <Self as ::buffa::MessageView>::decode_view_ctx(buf, ctx)
2990 }
2991 fn merge_view_field(
2992 &mut self,
2993 tag: ::buffa::encoding::Tag,
2994 cur: &'a [u8],
2995 before_tag: &'a [u8],
2996 ctx: ::buffa::DecodeContext<'_>,
2997 ) -> ::core::result::Result<&'a [u8], ::buffa::DecodeError> {
2998 let _ = ctx;
2999 #[allow(unused_variables)]
3000 let view = self;
3001 let mut cur = cur;
3002 match tag.field_number() {
3003 1u32 => {
3004 ::buffa::encoding::check_wire_type(
3005 tag,
3006 ::buffa::encoding::WireType::LengthDelimited,
3007 )?;
3008 let __sub_ctx = ctx.descend()?;
3009 let sub = ::buffa::types::borrow_bytes(&mut cur)?;
3010 match view.layer.as_mut() {
3011 Some(existing) => {
3012 ::buffa::MessageView::merge_into_view(
3013 existing,
3014 sub,
3015 __sub_ctx,
3016 )?
3017 }
3018 None => {
3019 view.layer = ::buffa::MessageFieldView::set(
3020 <super::super::super::super::v1::__buffa::view::LayerView as ::buffa::MessageView>::decode_view_ctx(
3021 sub,
3022 __sub_ctx,
3023 )?,
3024 );
3025 }
3026 }
3027 }
3028 _ => {
3029 ::buffa::encoding::skip_field_depth(tag, &mut cur, ctx.depth())?;
3030 let span_len = before_tag.len() - cur.len();
3031 view.__buffa_unknown_fields
3032 .push_record(before_tag, span_len, ctx)?;
3033 }
3034 }
3035 ::core::result::Result::Ok(cur)
3036 }
3037 fn to_owned_message(
3038 &self,
3039 ) -> ::core::result::Result<
3040 super::super::LayerUpdated,
3041 ::buffa::DecodeError,
3042 > {
3043 self.to_owned_from_source(None)
3044 }
3045 #[allow(clippy::useless_conversion, clippy::needless_update)]
3046 fn to_owned_from_source(
3047 &self,
3048 __buffa_src: ::core::option::Option<&::buffa::bytes::Bytes>,
3049 ) -> ::core::result::Result<
3050 super::super::LayerUpdated,
3051 ::buffa::DecodeError,
3052 > {
3053 #[allow(unused_imports)]
3054 use ::buffa::alloc::string::ToString as _;
3055 let _ = __buffa_src;
3056 ::core::result::Result::Ok(super::super::LayerUpdated {
3057 layer: match self.layer.as_option() {
3058 Some(v) => {
3059 ::buffa::MessageField::<
3060 super::super::super::super::v1::Layer,
3061 >::some(v.to_owned_from_source(__buffa_src)?)
3062 }
3063 None => ::buffa::MessageField::none(),
3064 },
3065 __buffa_unknown_fields: self
3066 .__buffa_unknown_fields
3067 .to_owned()?
3068 .into(),
3069 ..::core::default::Default::default()
3070 })
3071 }
3072 }
3073 impl<'a> ::buffa::ViewEncode<'a> for LayerUpdatedView<'a> {
3074 #[allow(clippy::needless_borrow, clippy::let_and_return)]
3075 fn compute_size(&self, __cache: &mut ::buffa::SizeCache) -> u32 {
3076 #[allow(unused_imports)]
3077 use ::buffa::Enumeration as _;
3078 let mut size = 0u32;
3079 if self.layer.is_set() {
3080 let __slot = __cache.reserve();
3081 let inner_size = self.layer.compute_size(__cache);
3082 __cache.set(__slot, inner_size);
3083 size
3084 += 1u32 + ::buffa::encoding::varint_len(inner_size as u64) as u32
3085 + inner_size;
3086 }
3087 size += self.__buffa_unknown_fields.encoded_len() as u32;
3088 size
3089 }
3090 #[allow(clippy::needless_borrow)]
3091 fn write_to(
3092 &self,
3093 __cache: &mut ::buffa::SizeCache,
3094 buf: &mut impl ::buffa::bytes::BufMut,
3095 ) {
3096 #[allow(unused_imports)]
3097 use ::buffa::Enumeration as _;
3098 if self.layer.is_set() {
3099 ::buffa::types::put_len_delimited_header(
3100 1u32,
3101 __cache.consume_next(),
3102 buf,
3103 );
3104 self.layer.write_to(__cache, buf);
3105 }
3106 self.__buffa_unknown_fields.write_to(buf);
3107 }
3108 }
3109 impl<'__a> ::serde::Serialize for LayerUpdatedView<'__a> {
3121 fn serialize<__S: ::serde::Serializer>(
3122 &self,
3123 __s: __S,
3124 ) -> ::core::result::Result<__S::Ok, __S::Error> {
3125 use ::serde::ser::SerializeMap as _;
3126 let mut __map = __s.serialize_map(::core::option::Option::None)?;
3127 {
3128 if let ::core::option::Option::Some(__v) = self.layer.as_option() {
3129 __map.serialize_entry("layer", __v)?;
3130 }
3131 }
3132 __map.end()
3133 }
3134 }
3135 impl<'a> ::buffa::MessageName for LayerUpdatedView<'a> {
3136 const PACKAGE: &'static str = "polychart.events.v1";
3137 const NAME: &'static str = "LayerUpdated";
3138 const FULL_NAME: &'static str = "polychart.events.v1.LayerUpdated";
3139 const TYPE_URL: &'static str = "type.googleapis.com/polychart.events.v1.LayerUpdated";
3140 }
3141 ::buffa::impl_default_view_instance!(LayerUpdatedView);
3142 ::buffa::impl_view_reborrow!(LayerUpdatedView);
3143 #[derive(Clone, Debug)]
3149 pub struct LayerUpdatedOwnedView(::buffa::OwnedView<LayerUpdatedView<'static>>);
3150 impl LayerUpdatedOwnedView {
3151 pub fn decode(
3161 bytes: ::buffa::bytes::Bytes,
3162 ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
3163 ::core::result::Result::Ok(
3164 LayerUpdatedOwnedView(::buffa::OwnedView::decode(bytes)?),
3165 )
3166 }
3167 pub fn decode_with_options(
3175 bytes: ::buffa::bytes::Bytes,
3176 opts: &::buffa::DecodeOptions,
3177 ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
3178 ::core::result::Result::Ok(
3179 LayerUpdatedOwnedView(
3180 ::buffa::OwnedView::decode_with_options(bytes, opts)?,
3181 ),
3182 )
3183 }
3184 pub fn from_owned(
3191 msg: &super::super::LayerUpdated,
3192 ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
3193 ::core::result::Result::Ok(
3194 LayerUpdatedOwnedView(::buffa::OwnedView::from_owned(msg)?),
3195 )
3196 }
3197 #[must_use]
3199 pub fn view(&self) -> &LayerUpdatedView<'_> {
3200 self.0.reborrow()
3201 }
3202 pub fn to_owned_message(
3209 &self,
3210 ) -> ::core::result::Result<
3211 super::super::LayerUpdated,
3212 ::buffa::DecodeError,
3213 > {
3214 self.0.to_owned_message()
3215 }
3216 #[must_use]
3218 pub fn bytes(&self) -> &::buffa::bytes::Bytes {
3219 self.0.bytes()
3220 }
3221 #[must_use]
3223 pub fn into_bytes(self) -> ::buffa::bytes::Bytes {
3224 self.0.into_bytes()
3225 }
3226 #[must_use]
3228 pub fn layer(
3229 &self,
3230 ) -> &::buffa::MessageFieldView<
3231 super::super::super::super::v1::__buffa::view::LayerView<'_>,
3232 > {
3233 &self.0.reborrow().layer
3234 }
3235 }
3236 impl ::core::convert::From<::buffa::OwnedView<LayerUpdatedView<'static>>>
3237 for LayerUpdatedOwnedView {
3238 fn from(inner: ::buffa::OwnedView<LayerUpdatedView<'static>>) -> Self {
3239 LayerUpdatedOwnedView(inner)
3240 }
3241 }
3242 impl ::core::convert::From<LayerUpdatedOwnedView>
3243 for ::buffa::OwnedView<LayerUpdatedView<'static>> {
3244 fn from(wrapper: LayerUpdatedOwnedView) -> Self {
3245 wrapper.0
3246 }
3247 }
3248 impl ::core::convert::AsRef<::buffa::OwnedView<LayerUpdatedView<'static>>>
3249 for LayerUpdatedOwnedView {
3250 fn as_ref(&self) -> &::buffa::OwnedView<LayerUpdatedView<'static>> {
3251 &self.0
3252 }
3253 }
3254 impl ::buffa::HasMessageView for super::super::LayerUpdated {
3255 type View<'a> = LayerUpdatedView<'a>;
3256 type ViewHandle = LayerUpdatedOwnedView;
3257 }
3258 impl ::serde::Serialize for LayerUpdatedOwnedView {
3259 fn serialize<__S: ::serde::Serializer>(
3260 &self,
3261 __s: __S,
3262 ) -> ::core::result::Result<__S::Ok, __S::Error> {
3263 ::serde::Serialize::serialize(&self.0, __s)
3264 }
3265 }
3266 #[derive(Clone, Debug, Default)]
3267 pub struct LayerDeletedView<'a> {
3268 pub layer: ::buffa::MessageFieldView<
3272 super::super::super::super::v1::__buffa::view::LayerRefView<'a>,
3273 >,
3274 pub layer_revision: u64,
3278 pub __buffa_unknown_fields: ::buffa::UnknownFieldsView<'a>,
3279 }
3280 impl<'a> ::buffa::MessageView<'a> for LayerDeletedView<'a> {
3281 type Owned = super::super::LayerDeleted;
3282 fn decode_view(
3283 buf: &'a [u8],
3284 ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
3285 let __limit = ::core::cell::Cell::new(
3286 ::buffa::DEFAULT_UNKNOWN_FIELD_LIMIT,
3287 );
3288 <Self as ::buffa::MessageView>::decode_view_ctx(
3289 buf,
3290 ::buffa::DecodeContext::new(::buffa::RECURSION_LIMIT, &__limit),
3291 )
3292 }
3293 fn decode_view_with_ctx(
3294 buf: &'a [u8],
3295 ctx: ::buffa::DecodeContext<'_>,
3296 ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
3297 <Self as ::buffa::MessageView>::decode_view_ctx(buf, ctx)
3298 }
3299 fn merge_view_field(
3300 &mut self,
3301 tag: ::buffa::encoding::Tag,
3302 cur: &'a [u8],
3303 before_tag: &'a [u8],
3304 ctx: ::buffa::DecodeContext<'_>,
3305 ) -> ::core::result::Result<&'a [u8], ::buffa::DecodeError> {
3306 let _ = ctx;
3307 #[allow(unused_variables)]
3308 let view = self;
3309 let mut cur = cur;
3310 match tag.field_number() {
3311 1u32 => {
3312 ::buffa::encoding::check_wire_type(
3313 tag,
3314 ::buffa::encoding::WireType::LengthDelimited,
3315 )?;
3316 let __sub_ctx = ctx.descend()?;
3317 let sub = ::buffa::types::borrow_bytes(&mut cur)?;
3318 match view.layer.as_mut() {
3319 Some(existing) => {
3320 ::buffa::MessageView::merge_into_view(
3321 existing,
3322 sub,
3323 __sub_ctx,
3324 )?
3325 }
3326 None => {
3327 view.layer = ::buffa::MessageFieldView::set(
3328 <super::super::super::super::v1::__buffa::view::LayerRefView as ::buffa::MessageView>::decode_view_ctx(
3329 sub,
3330 __sub_ctx,
3331 )?,
3332 );
3333 }
3334 }
3335 }
3336 2u32 => {
3337 ::buffa::encoding::check_wire_type(
3338 tag,
3339 ::buffa::encoding::WireType::Fixed64,
3340 )?;
3341 view.layer_revision = ::buffa::types::decode_fixed64(&mut cur)?;
3342 }
3343 _ => {
3344 ::buffa::encoding::skip_field_depth(tag, &mut cur, ctx.depth())?;
3345 let span_len = before_tag.len() - cur.len();
3346 view.__buffa_unknown_fields
3347 .push_record(before_tag, span_len, ctx)?;
3348 }
3349 }
3350 ::core::result::Result::Ok(cur)
3351 }
3352 fn to_owned_message(
3353 &self,
3354 ) -> ::core::result::Result<
3355 super::super::LayerDeleted,
3356 ::buffa::DecodeError,
3357 > {
3358 self.to_owned_from_source(None)
3359 }
3360 #[allow(clippy::useless_conversion, clippy::needless_update)]
3361 fn to_owned_from_source(
3362 &self,
3363 __buffa_src: ::core::option::Option<&::buffa::bytes::Bytes>,
3364 ) -> ::core::result::Result<
3365 super::super::LayerDeleted,
3366 ::buffa::DecodeError,
3367 > {
3368 #[allow(unused_imports)]
3369 use ::buffa::alloc::string::ToString as _;
3370 let _ = __buffa_src;
3371 ::core::result::Result::Ok(super::super::LayerDeleted {
3372 layer: match self.layer.as_option() {
3373 Some(v) => {
3374 ::buffa::MessageField::<
3375 super::super::super::super::v1::LayerRef,
3376 >::some(v.to_owned_from_source(__buffa_src)?)
3377 }
3378 None => ::buffa::MessageField::none(),
3379 },
3380 layer_revision: self.layer_revision,
3381 __buffa_unknown_fields: self
3382 .__buffa_unknown_fields
3383 .to_owned()?
3384 .into(),
3385 ..::core::default::Default::default()
3386 })
3387 }
3388 }
3389 impl<'a> ::buffa::ViewEncode<'a> for LayerDeletedView<'a> {
3390 #[allow(clippy::needless_borrow, clippy::let_and_return)]
3391 fn compute_size(&self, __cache: &mut ::buffa::SizeCache) -> u32 {
3392 #[allow(unused_imports)]
3393 use ::buffa::Enumeration as _;
3394 let mut size = 0u32;
3395 if self.layer.is_set() {
3396 let __slot = __cache.reserve();
3397 let inner_size = self.layer.compute_size(__cache);
3398 __cache.set(__slot, inner_size);
3399 size
3400 += 1u32 + ::buffa::encoding::varint_len(inner_size as u64) as u32
3401 + inner_size;
3402 }
3403 if self.layer_revision != 0u64 {
3404 size += 1u32 + ::buffa::types::FIXED64_ENCODED_LEN as u32;
3405 }
3406 size += self.__buffa_unknown_fields.encoded_len() as u32;
3407 size
3408 }
3409 #[allow(clippy::needless_borrow)]
3410 fn write_to(
3411 &self,
3412 __cache: &mut ::buffa::SizeCache,
3413 buf: &mut impl ::buffa::bytes::BufMut,
3414 ) {
3415 #[allow(unused_imports)]
3416 use ::buffa::Enumeration as _;
3417 if self.layer.is_set() {
3418 ::buffa::types::put_len_delimited_header(
3419 1u32,
3420 __cache.consume_next(),
3421 buf,
3422 );
3423 self.layer.write_to(__cache, buf);
3424 }
3425 if self.layer_revision != 0u64 {
3426 ::buffa::types::put_fixed64_field(2u32, self.layer_revision, buf);
3427 }
3428 self.__buffa_unknown_fields.write_to(buf);
3429 }
3430 }
3431 impl<'__a> ::serde::Serialize for LayerDeletedView<'__a> {
3443 fn serialize<__S: ::serde::Serializer>(
3444 &self,
3445 __s: __S,
3446 ) -> ::core::result::Result<__S::Ok, __S::Error> {
3447 use ::serde::ser::SerializeMap as _;
3448 let mut __map = __s.serialize_map(::core::option::Option::None)?;
3449 {
3450 if let ::core::option::Option::Some(__v) = self.layer.as_option() {
3451 __map.serialize_entry("layer", __v)?;
3452 }
3453 }
3454 if !::buffa::json_helpers::skip_if::is_zero_u64(&self.layer_revision) {
3455 __map
3456 .serialize_entry(
3457 "layerRevision",
3458 &::buffa::json_helpers::ProtoJson(&self.layer_revision),
3459 )?;
3460 }
3461 __map.end()
3462 }
3463 }
3464 impl<'a> ::buffa::MessageName for LayerDeletedView<'a> {
3465 const PACKAGE: &'static str = "polychart.events.v1";
3466 const NAME: &'static str = "LayerDeleted";
3467 const FULL_NAME: &'static str = "polychart.events.v1.LayerDeleted";
3468 const TYPE_URL: &'static str = "type.googleapis.com/polychart.events.v1.LayerDeleted";
3469 }
3470 ::buffa::impl_default_view_instance!(LayerDeletedView);
3471 ::buffa::impl_view_reborrow!(LayerDeletedView);
3472 #[derive(Clone, Debug)]
3478 pub struct LayerDeletedOwnedView(::buffa::OwnedView<LayerDeletedView<'static>>);
3479 impl LayerDeletedOwnedView {
3480 pub fn decode(
3490 bytes: ::buffa::bytes::Bytes,
3491 ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
3492 ::core::result::Result::Ok(
3493 LayerDeletedOwnedView(::buffa::OwnedView::decode(bytes)?),
3494 )
3495 }
3496 pub fn decode_with_options(
3504 bytes: ::buffa::bytes::Bytes,
3505 opts: &::buffa::DecodeOptions,
3506 ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
3507 ::core::result::Result::Ok(
3508 LayerDeletedOwnedView(
3509 ::buffa::OwnedView::decode_with_options(bytes, opts)?,
3510 ),
3511 )
3512 }
3513 pub fn from_owned(
3520 msg: &super::super::LayerDeleted,
3521 ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
3522 ::core::result::Result::Ok(
3523 LayerDeletedOwnedView(::buffa::OwnedView::from_owned(msg)?),
3524 )
3525 }
3526 #[must_use]
3528 pub fn view(&self) -> &LayerDeletedView<'_> {
3529 self.0.reborrow()
3530 }
3531 pub fn to_owned_message(
3538 &self,
3539 ) -> ::core::result::Result<
3540 super::super::LayerDeleted,
3541 ::buffa::DecodeError,
3542 > {
3543 self.0.to_owned_message()
3544 }
3545 #[must_use]
3547 pub fn bytes(&self) -> &::buffa::bytes::Bytes {
3548 self.0.bytes()
3549 }
3550 #[must_use]
3552 pub fn into_bytes(self) -> ::buffa::bytes::Bytes {
3553 self.0.into_bytes()
3554 }
3555 #[must_use]
3559 pub fn layer(
3560 &self,
3561 ) -> &::buffa::MessageFieldView<
3562 super::super::super::super::v1::__buffa::view::LayerRefView<'_>,
3563 > {
3564 &self.0.reborrow().layer
3565 }
3566 #[must_use]
3570 pub fn layer_revision(&self) -> u64 {
3571 self.0.reborrow().layer_revision
3572 }
3573 }
3574 impl ::core::convert::From<::buffa::OwnedView<LayerDeletedView<'static>>>
3575 for LayerDeletedOwnedView {
3576 fn from(inner: ::buffa::OwnedView<LayerDeletedView<'static>>) -> Self {
3577 LayerDeletedOwnedView(inner)
3578 }
3579 }
3580 impl ::core::convert::From<LayerDeletedOwnedView>
3581 for ::buffa::OwnedView<LayerDeletedView<'static>> {
3582 fn from(wrapper: LayerDeletedOwnedView) -> Self {
3583 wrapper.0
3584 }
3585 }
3586 impl ::core::convert::AsRef<::buffa::OwnedView<LayerDeletedView<'static>>>
3587 for LayerDeletedOwnedView {
3588 fn as_ref(&self) -> &::buffa::OwnedView<LayerDeletedView<'static>> {
3589 &self.0
3590 }
3591 }
3592 impl ::buffa::HasMessageView for super::super::LayerDeleted {
3593 type View<'a> = LayerDeletedView<'a>;
3594 type ViewHandle = LayerDeletedOwnedView;
3595 }
3596 impl ::serde::Serialize for LayerDeletedOwnedView {
3597 fn serialize<__S: ::serde::Serializer>(
3598 &self,
3599 __s: __S,
3600 ) -> ::core::result::Result<__S::Ok, __S::Error> {
3601 ::serde::Serialize::serialize(&self.0, __s)
3602 }
3603 }
3604 #[derive(Clone, Debug, Default)]
3605 pub struct LayerAccessGrantedView<'a> {
3606 pub layer: ::buffa::MessageFieldView<
3611 super::super::super::super::v1::__buffa::view::LayerView<'a>,
3612 >,
3613 pub __buffa_unknown_fields: ::buffa::UnknownFieldsView<'a>,
3614 }
3615 impl<'a> ::buffa::MessageView<'a> for LayerAccessGrantedView<'a> {
3616 type Owned = super::super::LayerAccessGranted;
3617 fn decode_view(
3618 buf: &'a [u8],
3619 ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
3620 let __limit = ::core::cell::Cell::new(
3621 ::buffa::DEFAULT_UNKNOWN_FIELD_LIMIT,
3622 );
3623 <Self as ::buffa::MessageView>::decode_view_ctx(
3624 buf,
3625 ::buffa::DecodeContext::new(::buffa::RECURSION_LIMIT, &__limit),
3626 )
3627 }
3628 fn decode_view_with_ctx(
3629 buf: &'a [u8],
3630 ctx: ::buffa::DecodeContext<'_>,
3631 ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
3632 <Self as ::buffa::MessageView>::decode_view_ctx(buf, ctx)
3633 }
3634 fn merge_view_field(
3635 &mut self,
3636 tag: ::buffa::encoding::Tag,
3637 cur: &'a [u8],
3638 before_tag: &'a [u8],
3639 ctx: ::buffa::DecodeContext<'_>,
3640 ) -> ::core::result::Result<&'a [u8], ::buffa::DecodeError> {
3641 let _ = ctx;
3642 #[allow(unused_variables)]
3643 let view = self;
3644 let mut cur = cur;
3645 match tag.field_number() {
3646 1u32 => {
3647 ::buffa::encoding::check_wire_type(
3648 tag,
3649 ::buffa::encoding::WireType::LengthDelimited,
3650 )?;
3651 let __sub_ctx = ctx.descend()?;
3652 let sub = ::buffa::types::borrow_bytes(&mut cur)?;
3653 match view.layer.as_mut() {
3654 Some(existing) => {
3655 ::buffa::MessageView::merge_into_view(
3656 existing,
3657 sub,
3658 __sub_ctx,
3659 )?
3660 }
3661 None => {
3662 view.layer = ::buffa::MessageFieldView::set(
3663 <super::super::super::super::v1::__buffa::view::LayerView as ::buffa::MessageView>::decode_view_ctx(
3664 sub,
3665 __sub_ctx,
3666 )?,
3667 );
3668 }
3669 }
3670 }
3671 _ => {
3672 ::buffa::encoding::skip_field_depth(tag, &mut cur, ctx.depth())?;
3673 let span_len = before_tag.len() - cur.len();
3674 view.__buffa_unknown_fields
3675 .push_record(before_tag, span_len, ctx)?;
3676 }
3677 }
3678 ::core::result::Result::Ok(cur)
3679 }
3680 fn to_owned_message(
3681 &self,
3682 ) -> ::core::result::Result<
3683 super::super::LayerAccessGranted,
3684 ::buffa::DecodeError,
3685 > {
3686 self.to_owned_from_source(None)
3687 }
3688 #[allow(clippy::useless_conversion, clippy::needless_update)]
3689 fn to_owned_from_source(
3690 &self,
3691 __buffa_src: ::core::option::Option<&::buffa::bytes::Bytes>,
3692 ) -> ::core::result::Result<
3693 super::super::LayerAccessGranted,
3694 ::buffa::DecodeError,
3695 > {
3696 #[allow(unused_imports)]
3697 use ::buffa::alloc::string::ToString as _;
3698 let _ = __buffa_src;
3699 ::core::result::Result::Ok(super::super::LayerAccessGranted {
3700 layer: match self.layer.as_option() {
3701 Some(v) => {
3702 ::buffa::MessageField::<
3703 super::super::super::super::v1::Layer,
3704 >::some(v.to_owned_from_source(__buffa_src)?)
3705 }
3706 None => ::buffa::MessageField::none(),
3707 },
3708 __buffa_unknown_fields: self
3709 .__buffa_unknown_fields
3710 .to_owned()?
3711 .into(),
3712 ..::core::default::Default::default()
3713 })
3714 }
3715 }
3716 impl<'a> ::buffa::ViewEncode<'a> for LayerAccessGrantedView<'a> {
3717 #[allow(clippy::needless_borrow, clippy::let_and_return)]
3718 fn compute_size(&self, __cache: &mut ::buffa::SizeCache) -> u32 {
3719 #[allow(unused_imports)]
3720 use ::buffa::Enumeration as _;
3721 let mut size = 0u32;
3722 if self.layer.is_set() {
3723 let __slot = __cache.reserve();
3724 let inner_size = self.layer.compute_size(__cache);
3725 __cache.set(__slot, inner_size);
3726 size
3727 += 1u32 + ::buffa::encoding::varint_len(inner_size as u64) as u32
3728 + inner_size;
3729 }
3730 size += self.__buffa_unknown_fields.encoded_len() as u32;
3731 size
3732 }
3733 #[allow(clippy::needless_borrow)]
3734 fn write_to(
3735 &self,
3736 __cache: &mut ::buffa::SizeCache,
3737 buf: &mut impl ::buffa::bytes::BufMut,
3738 ) {
3739 #[allow(unused_imports)]
3740 use ::buffa::Enumeration as _;
3741 if self.layer.is_set() {
3742 ::buffa::types::put_len_delimited_header(
3743 1u32,
3744 __cache.consume_next(),
3745 buf,
3746 );
3747 self.layer.write_to(__cache, buf);
3748 }
3749 self.__buffa_unknown_fields.write_to(buf);
3750 }
3751 }
3752 impl<'__a> ::serde::Serialize for LayerAccessGrantedView<'__a> {
3764 fn serialize<__S: ::serde::Serializer>(
3765 &self,
3766 __s: __S,
3767 ) -> ::core::result::Result<__S::Ok, __S::Error> {
3768 use ::serde::ser::SerializeMap as _;
3769 let mut __map = __s.serialize_map(::core::option::Option::None)?;
3770 {
3771 if let ::core::option::Option::Some(__v) = self.layer.as_option() {
3772 __map.serialize_entry("layer", __v)?;
3773 }
3774 }
3775 __map.end()
3776 }
3777 }
3778 impl<'a> ::buffa::MessageName for LayerAccessGrantedView<'a> {
3779 const PACKAGE: &'static str = "polychart.events.v1";
3780 const NAME: &'static str = "LayerAccessGranted";
3781 const FULL_NAME: &'static str = "polychart.events.v1.LayerAccessGranted";
3782 const TYPE_URL: &'static str = "type.googleapis.com/polychart.events.v1.LayerAccessGranted";
3783 }
3784 ::buffa::impl_default_view_instance!(LayerAccessGrantedView);
3785 ::buffa::impl_view_reborrow!(LayerAccessGrantedView);
3786 #[derive(Clone, Debug)]
3792 pub struct LayerAccessGrantedOwnedView(
3793 ::buffa::OwnedView<LayerAccessGrantedView<'static>>,
3794 );
3795 impl LayerAccessGrantedOwnedView {
3796 pub fn decode(
3806 bytes: ::buffa::bytes::Bytes,
3807 ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
3808 ::core::result::Result::Ok(
3809 LayerAccessGrantedOwnedView(::buffa::OwnedView::decode(bytes)?),
3810 )
3811 }
3812 pub fn decode_with_options(
3820 bytes: ::buffa::bytes::Bytes,
3821 opts: &::buffa::DecodeOptions,
3822 ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
3823 ::core::result::Result::Ok(
3824 LayerAccessGrantedOwnedView(
3825 ::buffa::OwnedView::decode_with_options(bytes, opts)?,
3826 ),
3827 )
3828 }
3829 pub fn from_owned(
3836 msg: &super::super::LayerAccessGranted,
3837 ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
3838 ::core::result::Result::Ok(
3839 LayerAccessGrantedOwnedView(::buffa::OwnedView::from_owned(msg)?),
3840 )
3841 }
3842 #[must_use]
3844 pub fn view(&self) -> &LayerAccessGrantedView<'_> {
3845 self.0.reborrow()
3846 }
3847 pub fn to_owned_message(
3854 &self,
3855 ) -> ::core::result::Result<
3856 super::super::LayerAccessGranted,
3857 ::buffa::DecodeError,
3858 > {
3859 self.0.to_owned_message()
3860 }
3861 #[must_use]
3863 pub fn bytes(&self) -> &::buffa::bytes::Bytes {
3864 self.0.bytes()
3865 }
3866 #[must_use]
3868 pub fn into_bytes(self) -> ::buffa::bytes::Bytes {
3869 self.0.into_bytes()
3870 }
3871 #[must_use]
3876 pub fn layer(
3877 &self,
3878 ) -> &::buffa::MessageFieldView<
3879 super::super::super::super::v1::__buffa::view::LayerView<'_>,
3880 > {
3881 &self.0.reborrow().layer
3882 }
3883 }
3884 impl ::core::convert::From<::buffa::OwnedView<LayerAccessGrantedView<'static>>>
3885 for LayerAccessGrantedOwnedView {
3886 fn from(inner: ::buffa::OwnedView<LayerAccessGrantedView<'static>>) -> Self {
3887 LayerAccessGrantedOwnedView(inner)
3888 }
3889 }
3890 impl ::core::convert::From<LayerAccessGrantedOwnedView>
3891 for ::buffa::OwnedView<LayerAccessGrantedView<'static>> {
3892 fn from(wrapper: LayerAccessGrantedOwnedView) -> Self {
3893 wrapper.0
3894 }
3895 }
3896 impl ::core::convert::AsRef<::buffa::OwnedView<LayerAccessGrantedView<'static>>>
3897 for LayerAccessGrantedOwnedView {
3898 fn as_ref(&self) -> &::buffa::OwnedView<LayerAccessGrantedView<'static>> {
3899 &self.0
3900 }
3901 }
3902 impl ::buffa::HasMessageView for super::super::LayerAccessGranted {
3903 type View<'a> = LayerAccessGrantedView<'a>;
3904 type ViewHandle = LayerAccessGrantedOwnedView;
3905 }
3906 impl ::serde::Serialize for LayerAccessGrantedOwnedView {
3907 fn serialize<__S: ::serde::Serializer>(
3908 &self,
3909 __s: __S,
3910 ) -> ::core::result::Result<__S::Ok, __S::Error> {
3911 ::serde::Serialize::serialize(&self.0, __s)
3912 }
3913 }
3914 #[derive(Clone, Debug, Default)]
3915 pub struct LayerAccessRevokedView<'a> {
3916 pub layer: ::buffa::MessageFieldView<
3920 super::super::super::super::v1::__buffa::view::LayerRefView<'a>,
3921 >,
3922 pub engine_symbol_id: u32,
3924 pub __buffa_unknown_fields: ::buffa::UnknownFieldsView<'a>,
3925 }
3926 impl<'a> ::buffa::MessageView<'a> for LayerAccessRevokedView<'a> {
3927 type Owned = super::super::LayerAccessRevoked;
3928 fn decode_view(
3929 buf: &'a [u8],
3930 ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
3931 let __limit = ::core::cell::Cell::new(
3932 ::buffa::DEFAULT_UNKNOWN_FIELD_LIMIT,
3933 );
3934 <Self as ::buffa::MessageView>::decode_view_ctx(
3935 buf,
3936 ::buffa::DecodeContext::new(::buffa::RECURSION_LIMIT, &__limit),
3937 )
3938 }
3939 fn decode_view_with_ctx(
3940 buf: &'a [u8],
3941 ctx: ::buffa::DecodeContext<'_>,
3942 ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
3943 <Self as ::buffa::MessageView>::decode_view_ctx(buf, ctx)
3944 }
3945 fn merge_view_field(
3946 &mut self,
3947 tag: ::buffa::encoding::Tag,
3948 cur: &'a [u8],
3949 before_tag: &'a [u8],
3950 ctx: ::buffa::DecodeContext<'_>,
3951 ) -> ::core::result::Result<&'a [u8], ::buffa::DecodeError> {
3952 let _ = ctx;
3953 #[allow(unused_variables)]
3954 let view = self;
3955 let mut cur = cur;
3956 match tag.field_number() {
3957 1u32 => {
3958 ::buffa::encoding::check_wire_type(
3959 tag,
3960 ::buffa::encoding::WireType::LengthDelimited,
3961 )?;
3962 let __sub_ctx = ctx.descend()?;
3963 let sub = ::buffa::types::borrow_bytes(&mut cur)?;
3964 match view.layer.as_mut() {
3965 Some(existing) => {
3966 ::buffa::MessageView::merge_into_view(
3967 existing,
3968 sub,
3969 __sub_ctx,
3970 )?
3971 }
3972 None => {
3973 view.layer = ::buffa::MessageFieldView::set(
3974 <super::super::super::super::v1::__buffa::view::LayerRefView as ::buffa::MessageView>::decode_view_ctx(
3975 sub,
3976 __sub_ctx,
3977 )?,
3978 );
3979 }
3980 }
3981 }
3982 2u32 => {
3983 ::buffa::encoding::check_wire_type(
3984 tag,
3985 ::buffa::encoding::WireType::Varint,
3986 )?;
3987 view.engine_symbol_id = ::buffa::types::decode_uint32(&mut cur)?;
3988 }
3989 _ => {
3990 ::buffa::encoding::skip_field_depth(tag, &mut cur, ctx.depth())?;
3991 let span_len = before_tag.len() - cur.len();
3992 view.__buffa_unknown_fields
3993 .push_record(before_tag, span_len, ctx)?;
3994 }
3995 }
3996 ::core::result::Result::Ok(cur)
3997 }
3998 fn to_owned_message(
3999 &self,
4000 ) -> ::core::result::Result<
4001 super::super::LayerAccessRevoked,
4002 ::buffa::DecodeError,
4003 > {
4004 self.to_owned_from_source(None)
4005 }
4006 #[allow(clippy::useless_conversion, clippy::needless_update)]
4007 fn to_owned_from_source(
4008 &self,
4009 __buffa_src: ::core::option::Option<&::buffa::bytes::Bytes>,
4010 ) -> ::core::result::Result<
4011 super::super::LayerAccessRevoked,
4012 ::buffa::DecodeError,
4013 > {
4014 #[allow(unused_imports)]
4015 use ::buffa::alloc::string::ToString as _;
4016 let _ = __buffa_src;
4017 ::core::result::Result::Ok(super::super::LayerAccessRevoked {
4018 layer: match self.layer.as_option() {
4019 Some(v) => {
4020 ::buffa::MessageField::<
4021 super::super::super::super::v1::LayerRef,
4022 >::some(v.to_owned_from_source(__buffa_src)?)
4023 }
4024 None => ::buffa::MessageField::none(),
4025 },
4026 engine_symbol_id: self.engine_symbol_id,
4027 __buffa_unknown_fields: self
4028 .__buffa_unknown_fields
4029 .to_owned()?
4030 .into(),
4031 ..::core::default::Default::default()
4032 })
4033 }
4034 }
4035 impl<'a> ::buffa::ViewEncode<'a> for LayerAccessRevokedView<'a> {
4036 #[allow(clippy::needless_borrow, clippy::let_and_return)]
4037 fn compute_size(&self, __cache: &mut ::buffa::SizeCache) -> u32 {
4038 #[allow(unused_imports)]
4039 use ::buffa::Enumeration as _;
4040 let mut size = 0u32;
4041 if self.layer.is_set() {
4042 let __slot = __cache.reserve();
4043 let inner_size = self.layer.compute_size(__cache);
4044 __cache.set(__slot, inner_size);
4045 size
4046 += 1u32 + ::buffa::encoding::varint_len(inner_size as u64) as u32
4047 + inner_size;
4048 }
4049 if self.engine_symbol_id != 0u32 {
4050 size
4051 += 1u32
4052 + ::buffa::types::uint32_encoded_len(self.engine_symbol_id)
4053 as u32;
4054 }
4055 size += self.__buffa_unknown_fields.encoded_len() as u32;
4056 size
4057 }
4058 #[allow(clippy::needless_borrow)]
4059 fn write_to(
4060 &self,
4061 __cache: &mut ::buffa::SizeCache,
4062 buf: &mut impl ::buffa::bytes::BufMut,
4063 ) {
4064 #[allow(unused_imports)]
4065 use ::buffa::Enumeration as _;
4066 if self.layer.is_set() {
4067 ::buffa::types::put_len_delimited_header(
4068 1u32,
4069 __cache.consume_next(),
4070 buf,
4071 );
4072 self.layer.write_to(__cache, buf);
4073 }
4074 if self.engine_symbol_id != 0u32 {
4075 ::buffa::types::put_uint32_field(2u32, self.engine_symbol_id, buf);
4076 }
4077 self.__buffa_unknown_fields.write_to(buf);
4078 }
4079 }
4080 impl<'__a> ::serde::Serialize for LayerAccessRevokedView<'__a> {
4092 fn serialize<__S: ::serde::Serializer>(
4093 &self,
4094 __s: __S,
4095 ) -> ::core::result::Result<__S::Ok, __S::Error> {
4096 use ::serde::ser::SerializeMap as _;
4097 let mut __map = __s.serialize_map(::core::option::Option::None)?;
4098 {
4099 if let ::core::option::Option::Some(__v) = self.layer.as_option() {
4100 __map.serialize_entry("layer", __v)?;
4101 }
4102 }
4103 if !::buffa::json_helpers::skip_if::is_zero_u32(&self.engine_symbol_id) {
4104 __map
4105 .serialize_entry(
4106 "engineSymbolId",
4107 &::buffa::json_helpers::ProtoJson(&self.engine_symbol_id),
4108 )?;
4109 }
4110 __map.end()
4111 }
4112 }
4113 impl<'a> ::buffa::MessageName for LayerAccessRevokedView<'a> {
4114 const PACKAGE: &'static str = "polychart.events.v1";
4115 const NAME: &'static str = "LayerAccessRevoked";
4116 const FULL_NAME: &'static str = "polychart.events.v1.LayerAccessRevoked";
4117 const TYPE_URL: &'static str = "type.googleapis.com/polychart.events.v1.LayerAccessRevoked";
4118 }
4119 ::buffa::impl_default_view_instance!(LayerAccessRevokedView);
4120 ::buffa::impl_view_reborrow!(LayerAccessRevokedView);
4121 #[derive(Clone, Debug)]
4127 pub struct LayerAccessRevokedOwnedView(
4128 ::buffa::OwnedView<LayerAccessRevokedView<'static>>,
4129 );
4130 impl LayerAccessRevokedOwnedView {
4131 pub fn decode(
4141 bytes: ::buffa::bytes::Bytes,
4142 ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
4143 ::core::result::Result::Ok(
4144 LayerAccessRevokedOwnedView(::buffa::OwnedView::decode(bytes)?),
4145 )
4146 }
4147 pub fn decode_with_options(
4155 bytes: ::buffa::bytes::Bytes,
4156 opts: &::buffa::DecodeOptions,
4157 ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
4158 ::core::result::Result::Ok(
4159 LayerAccessRevokedOwnedView(
4160 ::buffa::OwnedView::decode_with_options(bytes, opts)?,
4161 ),
4162 )
4163 }
4164 pub fn from_owned(
4171 msg: &super::super::LayerAccessRevoked,
4172 ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
4173 ::core::result::Result::Ok(
4174 LayerAccessRevokedOwnedView(::buffa::OwnedView::from_owned(msg)?),
4175 )
4176 }
4177 #[must_use]
4179 pub fn view(&self) -> &LayerAccessRevokedView<'_> {
4180 self.0.reborrow()
4181 }
4182 pub fn to_owned_message(
4189 &self,
4190 ) -> ::core::result::Result<
4191 super::super::LayerAccessRevoked,
4192 ::buffa::DecodeError,
4193 > {
4194 self.0.to_owned_message()
4195 }
4196 #[must_use]
4198 pub fn bytes(&self) -> &::buffa::bytes::Bytes {
4199 self.0.bytes()
4200 }
4201 #[must_use]
4203 pub fn into_bytes(self) -> ::buffa::bytes::Bytes {
4204 self.0.into_bytes()
4205 }
4206 #[must_use]
4210 pub fn layer(
4211 &self,
4212 ) -> &::buffa::MessageFieldView<
4213 super::super::super::super::v1::__buffa::view::LayerRefView<'_>,
4214 > {
4215 &self.0.reborrow().layer
4216 }
4217 #[must_use]
4219 pub fn engine_symbol_id(&self) -> u32 {
4220 self.0.reborrow().engine_symbol_id
4221 }
4222 }
4223 impl ::core::convert::From<::buffa::OwnedView<LayerAccessRevokedView<'static>>>
4224 for LayerAccessRevokedOwnedView {
4225 fn from(inner: ::buffa::OwnedView<LayerAccessRevokedView<'static>>) -> Self {
4226 LayerAccessRevokedOwnedView(inner)
4227 }
4228 }
4229 impl ::core::convert::From<LayerAccessRevokedOwnedView>
4230 for ::buffa::OwnedView<LayerAccessRevokedView<'static>> {
4231 fn from(wrapper: LayerAccessRevokedOwnedView) -> Self {
4232 wrapper.0
4233 }
4234 }
4235 impl ::core::convert::AsRef<::buffa::OwnedView<LayerAccessRevokedView<'static>>>
4236 for LayerAccessRevokedOwnedView {
4237 fn as_ref(&self) -> &::buffa::OwnedView<LayerAccessRevokedView<'static>> {
4238 &self.0
4239 }
4240 }
4241 impl ::buffa::HasMessageView for super::super::LayerAccessRevoked {
4242 type View<'a> = LayerAccessRevokedView<'a>;
4243 type ViewHandle = LayerAccessRevokedOwnedView;
4244 }
4245 impl ::serde::Serialize for LayerAccessRevokedOwnedView {
4246 fn serialize<__S: ::serde::Serializer>(
4247 &self,
4248 __s: __S,
4249 ) -> ::core::result::Result<__S::Ok, __S::Error> {
4250 ::serde::Serialize::serialize(&self.0, __s)
4251 }
4252 }
4253 pub mod oneof {
4254 #[allow(unused_imports)]
4255 use super::*;
4256 pub mod polychart_event_envelope {
4257 #[allow(unused_imports)]
4258 use super::*;
4259 #[derive(Clone, Debug)]
4260 pub enum Event<'a> {
4261 DrawingCommitted(
4262 ::buffa::alloc::boxed::Box<
4263 super::super::super::super::__buffa::view::DrawingCommittedView<
4264 'a,
4265 >,
4266 >,
4267 ),
4268 DrawingDeleted(
4269 ::buffa::alloc::boxed::Box<
4270 super::super::super::super::__buffa::view::DrawingDeletedView<
4271 'a,
4272 >,
4273 >,
4274 ),
4275 LayerUpdated(
4276 ::buffa::alloc::boxed::Box<
4277 super::super::super::super::__buffa::view::LayerUpdatedView<
4278 'a,
4279 >,
4280 >,
4281 ),
4282 LayerDeleted(
4283 ::buffa::alloc::boxed::Box<
4284 super::super::super::super::__buffa::view::LayerDeletedView<
4285 'a,
4286 >,
4287 >,
4288 ),
4289 LayerAccessGranted(
4290 ::buffa::alloc::boxed::Box<
4291 super::super::super::super::__buffa::view::LayerAccessGrantedView<
4292 'a,
4293 >,
4294 >,
4295 ),
4296 LayerAccessRevoked(
4297 ::buffa::alloc::boxed::Box<
4298 super::super::super::super::__buffa::view::LayerAccessRevokedView<
4299 'a,
4300 >,
4301 >,
4302 ),
4303 }
4304 }
4305 }
4306 }
4307 pub mod oneof {
4308 #[allow(unused_imports)]
4309 use super::*;
4310 pub mod polychart_event_envelope {
4311 #[allow(unused_imports)]
4312 use super::*;
4313 #[derive(Clone, PartialEq, Debug)]
4314 pub enum Event {
4315 DrawingCommitted(
4316 ::buffa::alloc::boxed::Box<super::super::super::DrawingCommitted>,
4317 ),
4318 DrawingDeleted(
4319 ::buffa::alloc::boxed::Box<super::super::super::DrawingDeleted>,
4320 ),
4321 LayerUpdated(
4322 ::buffa::alloc::boxed::Box<super::super::super::LayerUpdated>,
4323 ),
4324 LayerDeleted(
4325 ::buffa::alloc::boxed::Box<super::super::super::LayerDeleted>,
4326 ),
4327 LayerAccessGranted(
4328 ::buffa::alloc::boxed::Box<super::super::super::LayerAccessGranted>,
4329 ),
4330 LayerAccessRevoked(
4331 ::buffa::alloc::boxed::Box<super::super::super::LayerAccessRevoked>,
4332 ),
4333 }
4334 impl ::buffa::Oneof for Event {}
4335 impl From<super::super::super::DrawingCommitted> for Event {
4336 fn from(v: super::super::super::DrawingCommitted) -> Self {
4337 Self::DrawingCommitted(::buffa::alloc::boxed::Box::new(v))
4338 }
4339 }
4340 impl From<super::super::super::DrawingCommitted>
4341 for ::core::option::Option<Event> {
4342 fn from(v: super::super::super::DrawingCommitted) -> Self {
4343 Self::Some(Event::from(v))
4344 }
4345 }
4346 impl From<super::super::super::DrawingDeleted> for Event {
4347 fn from(v: super::super::super::DrawingDeleted) -> Self {
4348 Self::DrawingDeleted(::buffa::alloc::boxed::Box::new(v))
4349 }
4350 }
4351 impl From<super::super::super::DrawingDeleted>
4352 for ::core::option::Option<Event> {
4353 fn from(v: super::super::super::DrawingDeleted) -> Self {
4354 Self::Some(Event::from(v))
4355 }
4356 }
4357 impl From<super::super::super::LayerUpdated> for Event {
4358 fn from(v: super::super::super::LayerUpdated) -> Self {
4359 Self::LayerUpdated(::buffa::alloc::boxed::Box::new(v))
4360 }
4361 }
4362 impl From<super::super::super::LayerUpdated>
4363 for ::core::option::Option<Event> {
4364 fn from(v: super::super::super::LayerUpdated) -> Self {
4365 Self::Some(Event::from(v))
4366 }
4367 }
4368 impl From<super::super::super::LayerDeleted> for Event {
4369 fn from(v: super::super::super::LayerDeleted) -> Self {
4370 Self::LayerDeleted(::buffa::alloc::boxed::Box::new(v))
4371 }
4372 }
4373 impl From<super::super::super::LayerDeleted>
4374 for ::core::option::Option<Event> {
4375 fn from(v: super::super::super::LayerDeleted) -> Self {
4376 Self::Some(Event::from(v))
4377 }
4378 }
4379 impl From<super::super::super::LayerAccessGranted> for Event {
4380 fn from(v: super::super::super::LayerAccessGranted) -> Self {
4381 Self::LayerAccessGranted(::buffa::alloc::boxed::Box::new(v))
4382 }
4383 }
4384 impl From<super::super::super::LayerAccessGranted>
4385 for ::core::option::Option<Event> {
4386 fn from(v: super::super::super::LayerAccessGranted) -> Self {
4387 Self::Some(Event::from(v))
4388 }
4389 }
4390 impl From<super::super::super::LayerAccessRevoked> for Event {
4391 fn from(v: super::super::super::LayerAccessRevoked) -> Self {
4392 Self::LayerAccessRevoked(::buffa::alloc::boxed::Box::new(v))
4393 }
4394 }
4395 impl From<super::super::super::LayerAccessRevoked>
4396 for ::core::option::Option<Event> {
4397 fn from(v: super::super::super::LayerAccessRevoked) -> Self {
4398 Self::Some(Event::from(v))
4399 }
4400 }
4401 impl serde::Serialize for Event {
4402 fn serialize<S: serde::Serializer>(
4403 &self,
4404 s: S,
4405 ) -> ::core::result::Result<S::Ok, S::Error> {
4406 use serde::ser::SerializeMap;
4407 let mut map = s.serialize_map(Some(1))?;
4408 match self {
4409 Self::DrawingCommitted(v) => {
4410 map.serialize_entry("drawingCommitted", v)?;
4411 }
4412 Self::DrawingDeleted(v) => {
4413 map.serialize_entry("drawingDeleted", v)?;
4414 }
4415 Self::LayerUpdated(v) => {
4416 map.serialize_entry("layerUpdated", v)?;
4417 }
4418 Self::LayerDeleted(v) => {
4419 map.serialize_entry("layerDeleted", v)?;
4420 }
4421 Self::LayerAccessGranted(v) => {
4422 map.serialize_entry("layerAccessGranted", v)?;
4423 }
4424 Self::LayerAccessRevoked(v) => {
4425 map.serialize_entry("layerAccessRevoked", v)?;
4426 }
4427 }
4428 map.end()
4429 }
4430 }
4431 }
4432 }
4433 pub fn register_types(reg: &mut ::buffa::type_registry::TypeRegistry) {
4435 reg.register_json_any(super::__POLYCHART_EVENT_ENVELOPE_JSON_ANY);
4436 reg.register_json_any(super::__DRAWING_COMMITTED_JSON_ANY);
4437 reg.register_json_any(super::__DRAWING_DELETED_JSON_ANY);
4438 reg.register_json_any(super::__LAYER_UPDATED_JSON_ANY);
4439 reg.register_json_any(super::__LAYER_DELETED_JSON_ANY);
4440 reg.register_json_any(super::__LAYER_ACCESS_GRANTED_JSON_ANY);
4441 reg.register_json_any(super::__LAYER_ACCESS_REVOKED_JSON_ANY);
4442 }
4443}
4444#[doc(inline)]
4445pub use self::__buffa::view::PolychartEventEnvelopeView;
4446#[doc(inline)]
4447pub use self::__buffa::view::PolychartEventEnvelopeOwnedView;
4448#[doc(inline)]
4449pub use self::__buffa::view::DrawingCommittedView;
4450#[doc(inline)]
4451pub use self::__buffa::view::DrawingCommittedOwnedView;
4452#[doc(inline)]
4453pub use self::__buffa::view::DrawingDeletedView;
4454#[doc(inline)]
4455pub use self::__buffa::view::DrawingDeletedOwnedView;
4456#[doc(inline)]
4457pub use self::__buffa::view::LayerUpdatedView;
4458#[doc(inline)]
4459pub use self::__buffa::view::LayerUpdatedOwnedView;
4460#[doc(inline)]
4461pub use self::__buffa::view::LayerDeletedView;
4462#[doc(inline)]
4463pub use self::__buffa::view::LayerDeletedOwnedView;
4464#[doc(inline)]
4465pub use self::__buffa::view::LayerAccessGrantedView;
4466#[doc(inline)]
4467pub use self::__buffa::view::LayerAccessGrantedOwnedView;
4468#[doc(inline)]
4469pub use self::__buffa::view::LayerAccessRevokedView;
4470#[doc(inline)]
4471pub use self::__buffa::view::LayerAccessRevokedOwnedView;
4472#[doc(inline)]
4473pub use self::__buffa::register_types;