1#![allow(unused_imports)]
5#![allow(unused_parens)]
6#![allow(clippy::clone_on_copy)]
7#![allow(clippy::cloned_instead_of_copied)]
8#![allow(clippy::map_flatten)]
9#![allow(clippy::needless_question_mark)]
10#![allow(clippy::new_without_default)]
11#![allow(clippy::redundant_closure)]
12#![allow(clippy::too_many_arguments)]
13#![allow(clippy::too_many_lines)]
14
15use ::re_types_core::try_serialize_field;
16use ::re_types_core::SerializationResult;
17use ::re_types_core::{ComponentBatch as _, SerializedComponentBatch};
18use ::re_types_core::{ComponentDescriptor, ComponentName};
19use ::re_types_core::{DeserializationError, DeserializationResult};
20
21#[derive(Clone, Debug, Default, Copy, PartialEq, bytemuck::Pod, bytemuck::Zeroable)]
23#[repr(C)]
24pub struct Range2D {
25 pub x_range: crate::datatypes::Range1D,
27
28 pub y_range: crate::datatypes::Range1D,
30}
31
32::re_types_core::macros::impl_into_cow!(Range2D);
33
34impl ::re_types_core::Loggable for Range2D {
35 #[inline]
36 fn arrow_datatype() -> arrow::datatypes::DataType {
37 #![allow(clippy::wildcard_imports)]
38 use arrow::datatypes::*;
39 DataType::Struct(Fields::from(vec![
40 Field::new(
41 "x_range",
42 <crate::datatypes::Range1D>::arrow_datatype(),
43 false,
44 ),
45 Field::new(
46 "y_range",
47 <crate::datatypes::Range1D>::arrow_datatype(),
48 false,
49 ),
50 ]))
51 }
52
53 fn to_arrow_opt<'a>(
54 data: impl IntoIterator<Item = Option<impl Into<::std::borrow::Cow<'a, Self>>>>,
55 ) -> SerializationResult<arrow::array::ArrayRef>
56 where
57 Self: Clone + 'a,
58 {
59 #![allow(clippy::wildcard_imports)]
60 #![allow(clippy::manual_is_variant_and)]
61 use ::re_types_core::{arrow_helpers::as_array_ref, Loggable as _, ResultExt as _};
62 use arrow::{array::*, buffer::*, datatypes::*};
63 Ok({
64 let fields = Fields::from(vec![
65 Field::new(
66 "x_range",
67 <crate::datatypes::Range1D>::arrow_datatype(),
68 false,
69 ),
70 Field::new(
71 "y_range",
72 <crate::datatypes::Range1D>::arrow_datatype(),
73 false,
74 ),
75 ]);
76 let (somes, data): (Vec<_>, Vec<_>) = data
77 .into_iter()
78 .map(|datum| {
79 let datum: Option<::std::borrow::Cow<'a, Self>> = datum.map(Into::into);
80 (datum.is_some(), datum)
81 })
82 .unzip();
83 let validity: Option<arrow::buffer::NullBuffer> = {
84 let any_nones = somes.iter().any(|some| !*some);
85 any_nones.then(|| somes.into())
86 };
87 as_array_ref(StructArray::new(
88 fields,
89 vec![
90 {
91 let (somes, x_range): (Vec<_>, Vec<_>) = data
92 .iter()
93 .map(|datum| {
94 let datum = datum.as_ref().map(|datum| datum.x_range.clone());
95 (datum.is_some(), datum)
96 })
97 .unzip();
98 let x_range_validity: Option<arrow::buffer::NullBuffer> = {
99 let any_nones = somes.iter().any(|some| !*some);
100 any_nones.then(|| somes.into())
101 };
102 {
103 let x_range_inner_data: Vec<_> = x_range
104 .into_iter()
105 .map(|datum| datum.map(|datum| datum.0).unwrap_or_default())
106 .flatten()
107 .collect();
108 let x_range_inner_validity: Option<arrow::buffer::NullBuffer> =
109 x_range_validity.as_ref().map(|validity| {
110 validity
111 .iter()
112 .map(|b| std::iter::repeat(b).take(2usize))
113 .flatten()
114 .collect::<Vec<_>>()
115 .into()
116 });
117 as_array_ref(FixedSizeListArray::new(
118 std::sync::Arc::new(Field::new("item", DataType::Float64, false)),
119 2,
120 as_array_ref(PrimitiveArray::<Float64Type>::new(
121 ScalarBuffer::from(
122 x_range_inner_data.into_iter().collect::<Vec<_>>(),
123 ),
124 x_range_inner_validity,
125 )),
126 x_range_validity,
127 ))
128 }
129 },
130 {
131 let (somes, y_range): (Vec<_>, Vec<_>) = data
132 .iter()
133 .map(|datum| {
134 let datum = datum.as_ref().map(|datum| datum.y_range.clone());
135 (datum.is_some(), datum)
136 })
137 .unzip();
138 let y_range_validity: Option<arrow::buffer::NullBuffer> = {
139 let any_nones = somes.iter().any(|some| !*some);
140 any_nones.then(|| somes.into())
141 };
142 {
143 let y_range_inner_data: Vec<_> = y_range
144 .into_iter()
145 .map(|datum| datum.map(|datum| datum.0).unwrap_or_default())
146 .flatten()
147 .collect();
148 let y_range_inner_validity: Option<arrow::buffer::NullBuffer> =
149 y_range_validity.as_ref().map(|validity| {
150 validity
151 .iter()
152 .map(|b| std::iter::repeat(b).take(2usize))
153 .flatten()
154 .collect::<Vec<_>>()
155 .into()
156 });
157 as_array_ref(FixedSizeListArray::new(
158 std::sync::Arc::new(Field::new("item", DataType::Float64, false)),
159 2,
160 as_array_ref(PrimitiveArray::<Float64Type>::new(
161 ScalarBuffer::from(
162 y_range_inner_data.into_iter().collect::<Vec<_>>(),
163 ),
164 y_range_inner_validity,
165 )),
166 y_range_validity,
167 ))
168 }
169 },
170 ],
171 validity,
172 ))
173 })
174 }
175
176 fn from_arrow_opt(
177 arrow_data: &dyn arrow::array::Array,
178 ) -> DeserializationResult<Vec<Option<Self>>>
179 where
180 Self: Sized,
181 {
182 #![allow(clippy::wildcard_imports)]
183 use ::re_types_core::{arrow_zip_validity::ZipValidity, Loggable as _, ResultExt as _};
184 use arrow::{array::*, buffer::*, datatypes::*};
185 Ok({
186 let arrow_data = arrow_data
187 .as_any()
188 .downcast_ref::<arrow::array::StructArray>()
189 .ok_or_else(|| {
190 let expected = Self::arrow_datatype();
191 let actual = arrow_data.data_type().clone();
192 DeserializationError::datatype_mismatch(expected, actual)
193 })
194 .with_context("rerun.datatypes.Range2D")?;
195 if arrow_data.is_empty() {
196 Vec::new()
197 } else {
198 let (arrow_data_fields, arrow_data_arrays) =
199 (arrow_data.fields(), arrow_data.columns());
200 let arrays_by_name: ::std::collections::HashMap<_, _> = arrow_data_fields
201 .iter()
202 .map(|field| field.name().as_str())
203 .zip(arrow_data_arrays)
204 .collect();
205 let x_range = {
206 if !arrays_by_name.contains_key("x_range") {
207 return Err(DeserializationError::missing_struct_field(
208 Self::arrow_datatype(),
209 "x_range",
210 ))
211 .with_context("rerun.datatypes.Range2D");
212 }
213 let arrow_data = &**arrays_by_name["x_range"];
214 {
215 let arrow_data = arrow_data
216 .as_any()
217 .downcast_ref::<arrow::array::FixedSizeListArray>()
218 .ok_or_else(|| {
219 let expected = DataType::FixedSizeList(
220 std::sync::Arc::new(Field::new(
221 "item",
222 DataType::Float64,
223 false,
224 )),
225 2,
226 );
227 let actual = arrow_data.data_type().clone();
228 DeserializationError::datatype_mismatch(expected, actual)
229 })
230 .with_context("rerun.datatypes.Range2D#x_range")?;
231 if arrow_data.is_empty() {
232 Vec::new()
233 } else {
234 let offsets = (0..)
235 .step_by(2usize)
236 .zip((2usize..).step_by(2usize).take(arrow_data.len()));
237 let arrow_data_inner = {
238 let arrow_data_inner = &**arrow_data.values();
239 arrow_data_inner
240 .as_any()
241 .downcast_ref::<Float64Array>()
242 .ok_or_else(|| {
243 let expected = DataType::Float64;
244 let actual = arrow_data_inner.data_type().clone();
245 DeserializationError::datatype_mismatch(expected, actual)
246 })
247 .with_context("rerun.datatypes.Range2D#x_range")?
248 .into_iter()
249 .collect::<Vec<_>>()
250 };
251 ZipValidity::new_with_validity(offsets, arrow_data.nulls())
252 .map(|elem| {
253 elem.map(|(start, end): (usize, usize)| {
254 debug_assert!(end - start == 2usize);
255 if arrow_data_inner.len() < end {
256 return Err(DeserializationError::offset_slice_oob(
257 (start, end),
258 arrow_data_inner.len(),
259 ));
260 }
261
262 #[allow(unsafe_code, clippy::undocumented_unsafe_blocks)]
263 let data =
264 unsafe { arrow_data_inner.get_unchecked(start..end) };
265 let data =
266 data.iter().cloned().map(Option::unwrap_or_default);
267
268 #[allow(clippy::unwrap_used)]
270 Ok(array_init::from_iter(data).unwrap())
271 })
272 .transpose()
273 })
274 .map(|res_or_opt| {
275 res_or_opt
276 .map(|res_or_opt| res_or_opt.map(crate::datatypes::Range1D))
277 })
278 .collect::<DeserializationResult<Vec<Option<_>>>>()?
279 }
280 .into_iter()
281 }
282 };
283 let y_range = {
284 if !arrays_by_name.contains_key("y_range") {
285 return Err(DeserializationError::missing_struct_field(
286 Self::arrow_datatype(),
287 "y_range",
288 ))
289 .with_context("rerun.datatypes.Range2D");
290 }
291 let arrow_data = &**arrays_by_name["y_range"];
292 {
293 let arrow_data = arrow_data
294 .as_any()
295 .downcast_ref::<arrow::array::FixedSizeListArray>()
296 .ok_or_else(|| {
297 let expected = DataType::FixedSizeList(
298 std::sync::Arc::new(Field::new(
299 "item",
300 DataType::Float64,
301 false,
302 )),
303 2,
304 );
305 let actual = arrow_data.data_type().clone();
306 DeserializationError::datatype_mismatch(expected, actual)
307 })
308 .with_context("rerun.datatypes.Range2D#y_range")?;
309 if arrow_data.is_empty() {
310 Vec::new()
311 } else {
312 let offsets = (0..)
313 .step_by(2usize)
314 .zip((2usize..).step_by(2usize).take(arrow_data.len()));
315 let arrow_data_inner = {
316 let arrow_data_inner = &**arrow_data.values();
317 arrow_data_inner
318 .as_any()
319 .downcast_ref::<Float64Array>()
320 .ok_or_else(|| {
321 let expected = DataType::Float64;
322 let actual = arrow_data_inner.data_type().clone();
323 DeserializationError::datatype_mismatch(expected, actual)
324 })
325 .with_context("rerun.datatypes.Range2D#y_range")?
326 .into_iter()
327 .collect::<Vec<_>>()
328 };
329 ZipValidity::new_with_validity(offsets, arrow_data.nulls())
330 .map(|elem| {
331 elem.map(|(start, end): (usize, usize)| {
332 debug_assert!(end - start == 2usize);
333 if arrow_data_inner.len() < end {
334 return Err(DeserializationError::offset_slice_oob(
335 (start, end),
336 arrow_data_inner.len(),
337 ));
338 }
339
340 #[allow(unsafe_code, clippy::undocumented_unsafe_blocks)]
341 let data =
342 unsafe { arrow_data_inner.get_unchecked(start..end) };
343 let data =
344 data.iter().cloned().map(Option::unwrap_or_default);
345
346 #[allow(clippy::unwrap_used)]
348 Ok(array_init::from_iter(data).unwrap())
349 })
350 .transpose()
351 })
352 .map(|res_or_opt| {
353 res_or_opt
354 .map(|res_or_opt| res_or_opt.map(crate::datatypes::Range1D))
355 })
356 .collect::<DeserializationResult<Vec<Option<_>>>>()?
357 }
358 .into_iter()
359 }
360 };
361 ZipValidity::new_with_validity(
362 ::itertools::izip!(x_range, y_range),
363 arrow_data.nulls(),
364 )
365 .map(|opt| {
366 opt.map(|(x_range, y_range)| {
367 Ok(Self {
368 x_range: x_range
369 .ok_or_else(DeserializationError::missing_data)
370 .with_context("rerun.datatypes.Range2D#x_range")?,
371 y_range: y_range
372 .ok_or_else(DeserializationError::missing_data)
373 .with_context("rerun.datatypes.Range2D#y_range")?,
374 })
375 })
376 .transpose()
377 })
378 .collect::<DeserializationResult<Vec<_>>>()
379 .with_context("rerun.datatypes.Range2D")?
380 }
381 })
382 }
383}
384
385impl ::re_byte_size::SizeBytes for Range2D {
386 #[inline]
387 fn heap_size_bytes(&self) -> u64 {
388 self.x_range.heap_size_bytes() + self.y_range.heap_size_bytes()
389 }
390
391 #[inline]
392 fn is_pod() -> bool {
393 <crate::datatypes::Range1D>::is_pod() && <crate::datatypes::Range1D>::is_pod()
394 }
395}