buffa_types/generated/google.protobuf.any.rs
1// @generated by buffa-codegen. DO NOT EDIT.
2// source: google/protobuf/any.proto
3
4/// `Any` contains an arbitrary serialized protocol buffer message along with a
5/// URL that describes the type of the serialized message.
6///
7/// Protobuf library provides support to pack/unpack Any values in the form
8/// of utility functions or additional generated methods of the Any type.
9///
10/// Example 1: Pack and unpack a message in C++.
11///
12/// ```text
13/// Foo foo = ...;
14/// Any any;
15/// any.PackFrom(foo);
16/// ...
17/// if (any.UnpackTo(&foo)) {
18/// ...
19/// }
20/// ```
21///
22/// Example 2: Pack and unpack a message in Java.
23///
24/// ```text
25/// Foo foo = ...;
26/// Any any = Any.pack(foo);
27/// ...
28/// if (any.is(Foo.class)) {
29/// foo = any.unpack(Foo.class);
30/// }
31/// // or ...
32/// if (any.isSameTypeAs(Foo.getDefaultInstance())) {
33/// foo = any.unpack(Foo.getDefaultInstance());
34/// }
35/// ```
36///
37/// Example 3: Pack and unpack a message in Python.
38///
39/// ```text
40/// foo = Foo(...)
41/// any = Any()
42/// any.Pack(foo)
43/// ...
44/// if any.Is(Foo.DESCRIPTOR):
45/// any.Unpack(foo)
46/// ...
47/// ```
48///
49/// Example 4: Pack and unpack a message in Go
50///
51/// ```text
52/// foo := &pb.Foo{...}
53/// any, err := anypb.New(foo)
54/// if err != nil {
55/// ...
56/// }
57/// ...
58/// foo := &pb.Foo{}
59/// if err := any.UnmarshalTo(foo); err != nil {
60/// ...
61/// }
62/// ```
63///
64/// The pack methods provided by protobuf library will by default use
65/// 'type.googleapis.com/full.type.name' as the type URL and the unpack
66/// methods only use the fully qualified type name after the last '/'
67/// in the type URL, for example "foo.bar.com/x/y.z" will yield type
68/// name "y.z".
69///
70/// JSON
71/// ====
72/// The JSON representation of an `Any` value uses the regular
73/// representation of the deserialized, embedded message, with an
74/// additional field `@type` which contains the type URL. Example:
75///
76/// ```text
77/// package google.profile;
78/// message Person {
79/// string first_name = 1;
80/// string last_name = 2;
81/// }
82///
83/// {
84/// "@type": "type.googleapis.com/google.profile.Person",
85/// "firstName": <string>,
86/// "lastName": <string>
87/// }
88/// ```
89///
90/// If the embedded message type is well-known and has a custom JSON
91/// representation, that representation will be embedded adding a field
92/// `value` which holds the custom JSON in addition to the `@type`
93/// field. Example (for message [google.protobuf.Duration](crate::google::protobuf::Duration)):
94///
95/// ```text
96/// {
97/// "@type": "type.googleapis.com/google.protobuf.Duration",
98/// "value": "1.212s"
99/// }
100/// ```
101#[derive(Clone, PartialEq, Default)]
102#[cfg_attr(feature = "arbitrary", derive(::arbitrary::Arbitrary))]
103pub struct Any {
104 /// A URL/resource name that uniquely identifies the type of the serialized
105 /// protocol buffer message. This string must contain at least
106 /// one "/" character. The last segment of the URL's path must represent
107 /// the fully qualified name of the type (as in
108 /// `path/google.protobuf.Duration`). The name should be in a canonical form
109 /// (e.g., leading "." is not accepted).
110 ///
111 /// In practice, teams usually precompile into the binary all types that they
112 /// expect it to use in the context of Any. However, for URLs which use the
113 /// scheme `http`, `https`, or no scheme, one can optionally set up a type
114 /// server that maps type URLs to message definitions as follows:
115 ///
116 /// * If no scheme is provided, `https` is assumed.
117 /// * An HTTP GET on the URL must yield a \[google.protobuf.Type\]\[\]
118 /// value in binary format, or produce an error.
119 /// * Applications are allowed to cache lookup results based on the
120 /// URL, or have them precompiled into a binary to avoid any
121 /// lookup. Therefore, binary compatibility needs to be preserved
122 /// on changes to types. (Use versioned type names to manage
123 /// breaking changes.)
124 ///
125 /// Note: this functionality is not currently available in the official
126 /// protobuf release, and it is not used for type URLs beginning with
127 /// type.googleapis.com. As of May 2023, there are no widely used type server
128 /// implementations and no plans to implement one.
129 ///
130 /// Schemes other than `http`, `https` (or the empty scheme) might be
131 /// used with implementation specific semantics.
132 ///
133 /// Field 1: `type_url`
134 pub type_url: ::buffa::alloc::string::String,
135 /// Must be a valid serialized protocol buffer of the above specified type.
136 ///
137 /// Field 2: `value`
138 #[cfg_attr(
139 feature = "arbitrary",
140 arbitrary(with = ::buffa::__private::arbitrary_proto_bytes)
141 )]
142 pub value: ::buffa::bytes::Bytes,
143 #[doc(hidden)]
144 pub __buffa_unknown_fields: ::buffa::UnknownFields,
145}
146impl ::core::fmt::Debug for Any {
147 fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
148 f.debug_struct("Any")
149 .field("type_url", &self.type_url)
150 .field("value", &self.value)
151 .finish()
152 }
153}
154impl Any {
155 /// Protobuf type URL for this message, for use with `Any::pack` and
156 /// `Any::unpack_if`.
157 ///
158 /// Format: `type.googleapis.com/<fully.qualified.TypeName>`
159 pub const TYPE_URL: &'static str = "type.googleapis.com/google.protobuf.Any";
160}
161::buffa::impl_default_instance!(Any);
162#[cfg(feature = "reflect")]
163const _: () = {
164 impl ::buffa_descriptor::reflect::ReflectMessage for Any {
165 fn message_descriptor(&self) -> &::buffa_descriptor::MessageDescriptor {
166 __buffa::reflect::descriptor_pool()
167 .message(Self::__buffa_reflect_message_index())
168 }
169 fn pool(
170 &self,
171 ) -> &::buffa::alloc::sync::Arc<::buffa_descriptor::DescriptorPool> {
172 __buffa::reflect::descriptor_pool()
173 }
174 fn unknown_fields(&self) -> &::buffa::UnknownFields {
175 &self.__buffa_unknown_fields
176 }
177 fn get(
178 &self,
179 field: &::buffa_descriptor::FieldDescriptor,
180 ) -> ::buffa_descriptor::reflect::ValueRef<'_> {
181 #[allow(unused_imports)]
182 use ::buffa::Enumeration as _;
183 match field.number() {
184 1u32 => ::buffa_descriptor::reflect::ValueRef::String(&self.type_url),
185 2u32 => ::buffa_descriptor::reflect::ValueRef::Bytes(&self.value[..]),
186 _ => {
187 ::core::debug_assert!(
188 false,
189 "field number {} is not a member of this message's reflect get()",
190 field.number(),
191 );
192 ::buffa_descriptor::reflect::ValueRef::Bool(false)
193 }
194 }
195 }
196 fn has(&self, field: &::buffa_descriptor::FieldDescriptor) -> bool {
197 match field.number() {
198 1u32 => !self.type_url.is_empty(),
199 2u32 => !self.value.is_empty(),
200 _ => false,
201 }
202 }
203 fn for_each_set(
204 &self,
205 f: &mut dyn ::core::ops::FnMut(
206 &::buffa_descriptor::FieldDescriptor,
207 ::buffa_descriptor::reflect::ValueRef<'_>,
208 ),
209 ) {
210 let md = ::buffa_descriptor::reflect::ReflectMessage::message_descriptor(
211 self,
212 );
213 for fd in md.fields() {
214 if ::buffa_descriptor::reflect::ReflectMessage::has(self, fd) {
215 f(fd, ::buffa_descriptor::reflect::ReflectMessage::get(self, fd));
216 }
217 }
218 }
219 fn to_dynamic(&self) -> ::buffa_descriptor::reflect::DynamicMessage {
220 ::buffa_descriptor::reflect::DynamicMessage::from_message(
221 self,
222 ::buffa::alloc::sync::Arc::clone(__buffa::reflect::descriptor_pool()),
223 Self::__buffa_reflect_message_index(),
224 )
225 }
226 }
227 impl ::buffa_descriptor::reflect::ReflectElement for Any {
228 #[inline]
229 fn as_value_ref(&self) -> ::buffa_descriptor::reflect::ValueRef<'_> {
230 ::buffa_descriptor::reflect::ValueRef::Message(
231 ::buffa_descriptor::reflect::ReflectCow::Borrowed(self),
232 )
233 }
234 }
235 impl Any {
236 /// Memoized `MessageIndex` for this message type, resolved once
237 /// against the package's embedded descriptor pool.
238 #[doc(hidden)]
239 fn __buffa_reflect_message_index() -> ::buffa_descriptor::MessageIndex {
240 static IDX: ::std::sync::OnceLock<::buffa_descriptor::MessageIndex> = ::std::sync::OnceLock::new();
241 *IDX
242 .get_or_init(|| {
243 __buffa::reflect::descriptor_pool()
244 .message_index(<Self as ::buffa::MessageName>::FULL_NAME)
245 .expect(
246 "generated message is registered in the embedded descriptor pool",
247 )
248 })
249 }
250 }
251 impl ::buffa_descriptor::reflect::Reflectable for Any {
252 /// Vtable-mode reflective handle: borrows `self` directly. No
253 /// encode/decode round-trip and no allocation — the reflective
254 /// accessors read this message's fields in place.
255 #[inline]
256 fn reflect(&self) -> ::buffa_descriptor::reflect::ReflectCow<'_> {
257 ::buffa_descriptor::reflect::ReflectCow::Borrowed(self)
258 }
259 }
260};
261impl ::buffa::MessageName for Any {
262 const PACKAGE: &'static str = "google.protobuf";
263 const NAME: &'static str = "Any";
264 const FULL_NAME: &'static str = "google.protobuf.Any";
265 const TYPE_URL: &'static str = "type.googleapis.com/google.protobuf.Any";
266}
267impl ::buffa::Message for Any {
268 /// Returns the total encoded size in bytes.
269 ///
270 /// The result is a `u32`; the protobuf specification requires all
271 /// messages to fit within 2 GiB (2,147,483,647 bytes), so a
272 /// compliant message will never overflow this type.
273 #[allow(clippy::let_and_return)]
274 fn compute_size(&self, _cache: &mut ::buffa::SizeCache) -> u32 {
275 #[allow(unused_imports)]
276 use ::buffa::Enumeration as _;
277 let mut size = 0u32;
278 if !self.type_url.is_empty() {
279 size += 1u32 + ::buffa::types::string_encoded_len(&self.type_url) as u32;
280 }
281 if !self.value.is_empty() {
282 size += 1u32 + ::buffa::types::bytes_encoded_len(&self.value) as u32;
283 }
284 size += self.__buffa_unknown_fields.encoded_len() as u32;
285 size
286 }
287 fn write_to(
288 &self,
289 _cache: &mut ::buffa::SizeCache,
290 buf: &mut impl ::buffa::bytes::BufMut,
291 ) {
292 #[allow(unused_imports)]
293 use ::buffa::Enumeration as _;
294 if !self.type_url.is_empty() {
295 ::buffa::types::put_string_field(1u32, &self.type_url, buf);
296 }
297 if !self.value.is_empty() {
298 ::buffa::types::put_bytes_field(2u32, &self.value, buf);
299 }
300 self.__buffa_unknown_fields.write_to(buf);
301 }
302 fn merge_field(
303 &mut self,
304 tag: ::buffa::encoding::Tag,
305 buf: &mut impl ::buffa::bytes::Buf,
306 ctx: ::buffa::DecodeContext<'_>,
307 ) -> ::core::result::Result<(), ::buffa::DecodeError> {
308 #[allow(unused_imports)]
309 use ::buffa::bytes::Buf as _;
310 #[allow(unused_imports)]
311 use ::buffa::Enumeration as _;
312 match tag.field_number() {
313 1u32 => {
314 ::buffa::encoding::check_wire_type(
315 tag,
316 ::buffa::encoding::WireType::LengthDelimited,
317 )?;
318 ::buffa::types::merge_string(&mut self.type_url, buf)?;
319 }
320 2u32 => {
321 ::buffa::encoding::check_wire_type(
322 tag,
323 ::buffa::encoding::WireType::LengthDelimited,
324 )?;
325 self.value = ::buffa::types::decode_bytes_to_bytes(buf)?;
326 }
327 _ => {
328 self.__buffa_unknown_fields
329 .push(::buffa::encoding::decode_unknown_field(tag, buf, ctx)?);
330 }
331 }
332 ::core::result::Result::Ok(())
333 }
334 fn clear(&mut self) {
335 self.type_url.clear();
336 self.value = ::core::default::Default::default();
337 self.__buffa_unknown_fields.clear();
338 }
339}
340impl ::buffa::ExtensionSet for Any {
341 const PROTO_FQN: &'static str = "google.protobuf.Any";
342 fn unknown_fields(&self) -> &::buffa::UnknownFields {
343 &self.__buffa_unknown_fields
344 }
345 fn unknown_fields_mut(&mut self) -> &mut ::buffa::UnknownFields {
346 &mut self.__buffa_unknown_fields
347 }
348}
349#[doc(hidden)]
350pub const __ANY_TEXT_ANY: ::buffa::type_registry::TextAnyEntry = ::buffa::type_registry::TextAnyEntry {
351 type_url: "type.googleapis.com/google.protobuf.Any",
352 text_encode: ::buffa::type_registry::any_encode_text::<Any>,
353 text_merge: ::buffa::type_registry::any_merge_text::<Any>,
354};