buffa_types/generated/google.protobuf.timestamp.__view.rs
1// @generated by buffa-codegen. DO NOT EDIT.
2// source: google/protobuf/timestamp.proto
3
4/// A Timestamp represents a point in time independent of any time zone or local
5/// calendar, encoded as a count of seconds and fractions of seconds at
6/// nanosecond resolution. The count is relative to an epoch at UTC midnight on
7/// January 1, 1970, in the proleptic Gregorian calendar which extends the
8/// Gregorian calendar backwards to year one.
9///
10/// All minutes are 60 seconds long. Leap seconds are "smeared" so that no leap
11/// second table is needed for interpretation, using a \[24-hour linear
12/// smear\](<https://developers.google.com/time/smear>).
13///
14/// The range is from 0001-01-01T00:00:00Z to 9999-12-31T23:59:59.999999999Z. By
15/// restricting to that range, we ensure that we can convert to and from \[RFC
16/// 3339\](<https://www.ietf.org/rfc/rfc3339.txt>) date strings.
17///
18/// # Examples
19///
20/// Example 1: Compute Timestamp from POSIX `time()`.
21///
22/// ```text
23/// Timestamp timestamp;
24/// timestamp.set_seconds(time(NULL));
25/// timestamp.set_nanos(0);
26/// ```
27///
28/// Example 2: Compute Timestamp from POSIX `gettimeofday()`.
29///
30/// ```text
31/// struct timeval tv;
32/// gettimeofday(&tv, NULL);
33///
34/// Timestamp timestamp;
35/// timestamp.set_seconds(tv.tv_sec);
36/// timestamp.set_nanos(tv.tv_usec * 1000);
37/// ```
38///
39/// Example 3: Compute Timestamp from Win32 `GetSystemTimeAsFileTime()`.
40///
41/// ```text
42/// FILETIME ft;
43/// GetSystemTimeAsFileTime(&ft);
44/// UINT64 ticks = (((UINT64)ft.dwHighDateTime) << 32) | ft.dwLowDateTime;
45///
46/// // A Windows tick is 100 nanoseconds. Windows epoch 1601-01-01T00:00:00Z
47/// // is 11644473600 seconds before Unix epoch 1970-01-01T00:00:00Z.
48/// Timestamp timestamp;
49/// timestamp.set_seconds((INT64) ((ticks / 10000000) - 11644473600LL));
50/// timestamp.set_nanos((INT32) ((ticks % 10000000) * 100));
51/// ```
52///
53/// Example 4: Compute Timestamp from Java `System.currentTimeMillis()`.
54///
55/// ```text
56/// long millis = System.currentTimeMillis();
57///
58/// Timestamp timestamp = Timestamp.newBuilder().setSeconds(millis / 1000)
59/// .setNanos((int) ((millis % 1000) * 1000000)).build();
60/// ```
61///
62/// Example 5: Compute Timestamp from Java `Instant.now()`.
63///
64/// ```text
65/// Instant now = Instant.now();
66///
67/// Timestamp timestamp =
68/// Timestamp.newBuilder().setSeconds(now.getEpochSecond())
69/// .setNanos(now.getNano()).build();
70/// ```
71///
72/// Example 6: Compute Timestamp from current time in Python.
73///
74/// ```text
75/// timestamp = Timestamp()
76/// timestamp.GetCurrentTime()
77/// ```
78///
79/// # JSON Mapping
80///
81/// In JSON format, the Timestamp type is encoded as a string in the
82/// [RFC 3339](https://www.ietf.org/rfc/rfc3339.txt) format. That is, the
83/// format is "{year}-{month}-{day}T{hour}:{min}:{sec}\[.{frac_sec}\]Z"
84/// where {year} is always expressed using four digits while {month}, {day},
85/// {hour}, {min}, and {sec} are zero-padded to two digits each. The fractional
86/// seconds, which can go up to 9 digits (i.e. up to 1 nanosecond resolution),
87/// are optional. The "Z" suffix indicates the timezone ("UTC"); the timezone
88/// is required. A proto3 JSON serializer should always use UTC (as indicated by
89/// "Z") when printing the Timestamp type and a proto3 JSON parser should be
90/// able to accept both UTC and other timezones (as indicated by an offset).
91///
92/// For example, "2017-01-15T01:30:15.01Z" encodes 15.01 seconds past
93/// 01:30 UTC on January 15, 2017.
94///
95/// In JavaScript, one can convert a Date object to this format using the
96/// standard
97/// [toISOString()](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/toISOString)
98/// method. In Python, a standard `datetime.datetime` object can be converted
99/// to this format using
100/// [`strftime`](https://docs.python.org/2/library/time.html#time.strftime) with
101/// the time format spec '%Y-%m-%dT%H:%M:%S.%fZ'. Likewise, in Java, one can use
102/// the Joda Time's \[`ISODateTimeFormat.dateTime()`\](
103/// <http://joda-time.sourceforge.net/apidocs/org/joda/time/format/ISODateTimeFormat.html#dateTime(>)
104/// ) to obtain a formatter capable of generating timestamps in this format.
105#[derive(Clone, Debug, Default)]
106pub struct TimestampView<'a> {
107 /// Represents seconds of UTC time since Unix epoch
108 /// 1970-01-01T00:00:00Z. Must be from 0001-01-01T00:00:00Z to
109 /// 9999-12-31T23:59:59Z inclusive.
110 ///
111 /// Field 1: `seconds`
112 pub seconds: i64,
113 /// Non-negative fractions of a second at nanosecond resolution. Negative
114 /// second values with fractions must still have non-negative nanos values
115 /// that count forward in time. Must be from 0 to 999,999,999
116 /// inclusive.
117 ///
118 /// Field 2: `nanos`
119 pub nanos: i32,
120 pub __buffa_unknown_fields: ::buffa::UnknownFieldsView<'a>,
121}
122impl<'a> TimestampView<'a> {
123 /// Decode from `buf`, enforcing a recursion depth limit for nested messages.
124 ///
125 /// Called by [`::buffa::MessageView::decode_view`] with [`::buffa::RECURSION_LIMIT`]
126 /// and by generated sub-message decode arms with `depth - 1`.
127 ///
128 /// **Not part of the public API.** Named with a leading underscore to
129 /// signal that it is for generated-code use only.
130 #[doc(hidden)]
131 pub fn _decode_depth(
132 buf: &'a [u8],
133 depth: u32,
134 ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
135 let mut view = Self::default();
136 view._merge_into_view(buf, depth)?;
137 ::core::result::Result::Ok(view)
138 }
139 /// Merge fields from `buf` into this view (proto merge semantics).
140 ///
141 /// Repeated fields append; singular fields last-wins; singular
142 /// MESSAGE fields merge recursively. Used by sub-message decode
143 /// arms when the same field appears multiple times on the wire.
144 ///
145 /// **Not part of the public API.**
146 #[doc(hidden)]
147 pub fn _merge_into_view(
148 &mut self,
149 buf: &'a [u8],
150 depth: u32,
151 ) -> ::core::result::Result<(), ::buffa::DecodeError> {
152 let _ = depth;
153 #[allow(unused_variables)]
154 let view = self;
155 let mut cur: &'a [u8] = buf;
156 while !cur.is_empty() {
157 let before_tag = cur;
158 let tag = ::buffa::encoding::Tag::decode(&mut cur)?;
159 match tag.field_number() {
160 1u32 => {
161 if tag.wire_type() != ::buffa::encoding::WireType::Varint {
162 return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
163 field_number: 1u32,
164 expected: 0u8,
165 actual: tag.wire_type() as u8,
166 });
167 }
168 view.seconds = ::buffa::types::decode_int64(&mut cur)?;
169 }
170 2u32 => {
171 if tag.wire_type() != ::buffa::encoding::WireType::Varint {
172 return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
173 field_number: 2u32,
174 expected: 0u8,
175 actual: tag.wire_type() as u8,
176 });
177 }
178 view.nanos = ::buffa::types::decode_int32(&mut cur)?;
179 }
180 _ => {
181 ::buffa::encoding::skip_field_depth(tag, &mut cur, depth)?;
182 let span_len = before_tag.len() - cur.len();
183 view.__buffa_unknown_fields.push_raw(&before_tag[..span_len]);
184 }
185 }
186 }
187 ::core::result::Result::Ok(())
188 }
189}
190impl<'a> ::buffa::MessageView<'a> for TimestampView<'a> {
191 type Owned = super::super::Timestamp;
192 fn decode_view(buf: &'a [u8]) -> ::core::result::Result<Self, ::buffa::DecodeError> {
193 Self::_decode_depth(buf, ::buffa::RECURSION_LIMIT)
194 }
195 fn decode_view_with_limit(
196 buf: &'a [u8],
197 depth: u32,
198 ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
199 Self::_decode_depth(buf, depth)
200 }
201 fn to_owned_message(&self) -> super::super::Timestamp {
202 self.to_owned_from_source(None)
203 }
204 #[allow(clippy::useless_conversion, clippy::needless_update)]
205 fn to_owned_from_source(
206 &self,
207 __buffa_src: ::core::option::Option<&::buffa::bytes::Bytes>,
208 ) -> super::super::Timestamp {
209 #[allow(unused_imports)]
210 use ::buffa::alloc::string::ToString as _;
211 let _ = __buffa_src;
212 super::super::Timestamp {
213 seconds: self.seconds,
214 nanos: self.nanos,
215 __buffa_unknown_fields: self
216 .__buffa_unknown_fields
217 .to_owned()
218 .unwrap_or_default()
219 .into(),
220 ..::core::default::Default::default()
221 }
222 }
223}
224impl<'a> ::buffa::ViewEncode<'a> for TimestampView<'a> {
225 #[allow(clippy::needless_borrow, clippy::let_and_return)]
226 fn compute_size(&self, _cache: &mut ::buffa::SizeCache) -> u32 {
227 #[allow(unused_imports)]
228 use ::buffa::Enumeration as _;
229 let mut size = 0u32;
230 if self.seconds != 0i64 {
231 size += 1u32 + ::buffa::types::int64_encoded_len(self.seconds) as u32;
232 }
233 if self.nanos != 0i32 {
234 size += 1u32 + ::buffa::types::int32_encoded_len(self.nanos) as u32;
235 }
236 size += self.__buffa_unknown_fields.encoded_len() as u32;
237 size
238 }
239 #[allow(clippy::needless_borrow)]
240 fn write_to(
241 &self,
242 _cache: &mut ::buffa::SizeCache,
243 buf: &mut impl ::buffa::bytes::BufMut,
244 ) {
245 #[allow(unused_imports)]
246 use ::buffa::Enumeration as _;
247 if self.seconds != 0i64 {
248 ::buffa::encoding::Tag::new(1u32, ::buffa::encoding::WireType::Varint)
249 .encode(buf);
250 ::buffa::types::encode_int64(self.seconds, buf);
251 }
252 if self.nanos != 0i32 {
253 ::buffa::encoding::Tag::new(2u32, ::buffa::encoding::WireType::Varint)
254 .encode(buf);
255 ::buffa::types::encode_int32(self.nanos, buf);
256 }
257 self.__buffa_unknown_fields.write_to(buf);
258 }
259}
260impl<'a> ::buffa::MessageName for TimestampView<'a> {
261 const PACKAGE: &'static str = "google.protobuf";
262 const NAME: &'static str = "Timestamp";
263 const FULL_NAME: &'static str = "google.protobuf.Timestamp";
264 const TYPE_URL: &'static str = "type.googleapis.com/google.protobuf.Timestamp";
265}
266impl<'v> ::buffa::DefaultViewInstance for TimestampView<'v> {
267 fn default_view_instance<'a>() -> &'a Self
268 where
269 Self: 'a,
270 {
271 static VALUE: ::buffa::__private::OnceBox<TimestampView<'static>> = ::buffa::__private::OnceBox::new();
272 VALUE
273 .get_or_init(|| ::buffa::alloc::boxed::Box::new(
274 <TimestampView<'static>>::default(),
275 ))
276 }
277}
278impl ::buffa::ViewReborrow for TimestampView<'static> {
279 type Reborrowed<'b> = TimestampView<'b>;
280 fn reborrow<'b>(this: &'b Self) -> &'b Self::Reborrowed<'b> {
281 this
282 }
283}