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