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_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}
161impl ::buffa::DefaultInstance for Any {
162 fn default_instance() -> &'static Self {
163 static VALUE: ::buffa::__private::OnceBox<Any> = ::buffa::__private::OnceBox::new();
164 VALUE.get_or_init(|| ::buffa::alloc::boxed::Box::new(Self::default()))
165 }
166}
167impl ::buffa::MessageName for Any {
168 const PACKAGE: &'static str = "google.protobuf";
169 const NAME: &'static str = "Any";
170 const FULL_NAME: &'static str = "google.protobuf.Any";
171 const TYPE_URL: &'static str = "type.googleapis.com/google.protobuf.Any";
172}
173impl ::buffa::Message for Any {
174 /// Returns the total encoded size in bytes.
175 ///
176 /// The result is a `u32`; the protobuf specification requires all
177 /// messages to fit within 2 GiB (2,147,483,647 bytes), so a
178 /// compliant message will never overflow this type.
179 #[allow(clippy::let_and_return)]
180 fn compute_size(&self, _cache: &mut ::buffa::SizeCache) -> u32 {
181 #[allow(unused_imports)]
182 use ::buffa::Enumeration as _;
183 let mut size = 0u32;
184 if !self.type_url.is_empty() {
185 size += 1u32 + ::buffa::types::string_encoded_len(&self.type_url) as u32;
186 }
187 if !self.value.is_empty() {
188 size += 1u32 + ::buffa::types::bytes_encoded_len(&self.value) as u32;
189 }
190 size += self.__buffa_unknown_fields.encoded_len() as u32;
191 size
192 }
193 fn write_to(
194 &self,
195 _cache: &mut ::buffa::SizeCache,
196 buf: &mut impl ::buffa::bytes::BufMut,
197 ) {
198 #[allow(unused_imports)]
199 use ::buffa::Enumeration as _;
200 if !self.type_url.is_empty() {
201 ::buffa::encoding::Tag::new(
202 1u32,
203 ::buffa::encoding::WireType::LengthDelimited,
204 )
205 .encode(buf);
206 ::buffa::types::encode_string(&self.type_url, buf);
207 }
208 if !self.value.is_empty() {
209 ::buffa::encoding::Tag::new(
210 2u32,
211 ::buffa::encoding::WireType::LengthDelimited,
212 )
213 .encode(buf);
214 ::buffa::types::encode_bytes(&self.value, buf);
215 }
216 self.__buffa_unknown_fields.write_to(buf);
217 }
218 fn merge_field(
219 &mut self,
220 tag: ::buffa::encoding::Tag,
221 buf: &mut impl ::buffa::bytes::Buf,
222 depth: u32,
223 ) -> ::core::result::Result<(), ::buffa::DecodeError> {
224 #[allow(unused_imports)]
225 use ::buffa::bytes::Buf as _;
226 #[allow(unused_imports)]
227 use ::buffa::Enumeration as _;
228 match tag.field_number() {
229 1u32 => {
230 if tag.wire_type() != ::buffa::encoding::WireType::LengthDelimited {
231 return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
232 field_number: 1u32,
233 expected: 2u8,
234 actual: tag.wire_type() as u8,
235 });
236 }
237 ::buffa::types::merge_string(&mut self.type_url, buf)?;
238 }
239 2u32 => {
240 if tag.wire_type() != ::buffa::encoding::WireType::LengthDelimited {
241 return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
242 field_number: 2u32,
243 expected: 2u8,
244 actual: tag.wire_type() as u8,
245 });
246 }
247 self.value = ::buffa::types::decode_bytes_to_bytes(buf)?;
248 }
249 _ => {
250 self.__buffa_unknown_fields
251 .push(::buffa::encoding::decode_unknown_field(tag, buf, depth)?);
252 }
253 }
254 ::core::result::Result::Ok(())
255 }
256 fn clear(&mut self) {
257 self.type_url.clear();
258 self.value = ::buffa::bytes::Bytes::new();
259 self.__buffa_unknown_fields.clear();
260 }
261}
262impl ::buffa::ExtensionSet for Any {
263 const PROTO_FQN: &'static str = "google.protobuf.Any";
264 fn unknown_fields(&self) -> &::buffa::UnknownFields {
265 &self.__buffa_unknown_fields
266 }
267 fn unknown_fields_mut(&mut self) -> &mut ::buffa::UnknownFields {
268 &mut self.__buffa_unknown_fields
269 }
270}
271#[doc(hidden)]
272pub const __ANY_TEXT_ANY: ::buffa::type_registry::TextAnyEntry = ::buffa::type_registry::TextAnyEntry {
273 type_url: "type.googleapis.com/google.protobuf.Any",
274 text_encode: ::buffa::type_registry::any_encode_text::<Any>,
275 text_merge: ::buffa::type_registry::any_merge_text::<Any>,
276};