re_types/datatypes/
tensor_dimension_selection.rs

1// DO NOT EDIT! This file was auto-generated by crates/build/re_types_builder/src/codegen/rust/api.rs
2// Based on "crates/store/re_types/definitions/rerun/datatypes/tensor_dimension_selection.fbs".
3
4#![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/// **Datatype**: Selection of a single tensor dimension.
23#[derive(Clone, Debug, Default, Copy, Hash, PartialEq, Eq)]
24pub struct TensorDimensionSelection {
25    /// The dimension number to select.
26    pub dimension: u32,
27
28    /// Invert the direction of the dimension.
29    pub invert: bool,
30}
31
32::re_types_core::macros::impl_into_cow!(TensorDimensionSelection);
33
34impl ::re_types_core::Loggable for TensorDimensionSelection {
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("dimension", DataType::UInt32, false),
41            Field::new("invert", DataType::Boolean, false),
42        ]))
43    }
44
45    fn to_arrow_opt<'a>(
46        data: impl IntoIterator<Item = Option<impl Into<::std::borrow::Cow<'a, Self>>>>,
47    ) -> SerializationResult<arrow::array::ArrayRef>
48    where
49        Self: Clone + 'a,
50    {
51        #![allow(clippy::wildcard_imports)]
52        #![allow(clippy::manual_is_variant_and)]
53        use ::re_types_core::{arrow_helpers::as_array_ref, Loggable as _, ResultExt as _};
54        use arrow::{array::*, buffer::*, datatypes::*};
55        Ok({
56            let fields = Fields::from(vec![
57                Field::new("dimension", DataType::UInt32, false),
58                Field::new("invert", DataType::Boolean, false),
59            ]);
60            let (somes, data): (Vec<_>, Vec<_>) = data
61                .into_iter()
62                .map(|datum| {
63                    let datum: Option<::std::borrow::Cow<'a, Self>> = datum.map(Into::into);
64                    (datum.is_some(), datum)
65                })
66                .unzip();
67            let validity: Option<arrow::buffer::NullBuffer> = {
68                let any_nones = somes.iter().any(|some| !*some);
69                any_nones.then(|| somes.into())
70            };
71            as_array_ref(StructArray::new(
72                fields,
73                vec![
74                    {
75                        let (somes, dimension): (Vec<_>, Vec<_>) = data
76                            .iter()
77                            .map(|datum| {
78                                let datum = datum.as_ref().map(|datum| datum.dimension.clone());
79                                (datum.is_some(), datum)
80                            })
81                            .unzip();
82                        let dimension_validity: Option<arrow::buffer::NullBuffer> = {
83                            let any_nones = somes.iter().any(|some| !*some);
84                            any_nones.then(|| somes.into())
85                        };
86                        as_array_ref(PrimitiveArray::<UInt32Type>::new(
87                            ScalarBuffer::from(
88                                dimension
89                                    .into_iter()
90                                    .map(|v| v.unwrap_or_default())
91                                    .collect::<Vec<_>>(),
92                            ),
93                            dimension_validity,
94                        ))
95                    },
96                    {
97                        let (somes, invert): (Vec<_>, Vec<_>) = data
98                            .iter()
99                            .map(|datum| {
100                                let datum = datum.as_ref().map(|datum| datum.invert.clone());
101                                (datum.is_some(), datum)
102                            })
103                            .unzip();
104                        let invert_validity: Option<arrow::buffer::NullBuffer> = {
105                            let any_nones = somes.iter().any(|some| !*some);
106                            any_nones.then(|| somes.into())
107                        };
108                        as_array_ref(BooleanArray::new(
109                            BooleanBuffer::from(
110                                invert
111                                    .into_iter()
112                                    .map(|v| v.unwrap_or_default())
113                                    .collect::<Vec<_>>(),
114                            ),
115                            invert_validity,
116                        ))
117                    },
118                ],
119                validity,
120            ))
121        })
122    }
123
124    fn from_arrow_opt(
125        arrow_data: &dyn arrow::array::Array,
126    ) -> DeserializationResult<Vec<Option<Self>>>
127    where
128        Self: Sized,
129    {
130        #![allow(clippy::wildcard_imports)]
131        use ::re_types_core::{arrow_zip_validity::ZipValidity, Loggable as _, ResultExt as _};
132        use arrow::{array::*, buffer::*, datatypes::*};
133        Ok({
134            let arrow_data = arrow_data
135                .as_any()
136                .downcast_ref::<arrow::array::StructArray>()
137                .ok_or_else(|| {
138                    let expected = Self::arrow_datatype();
139                    let actual = arrow_data.data_type().clone();
140                    DeserializationError::datatype_mismatch(expected, actual)
141                })
142                .with_context("rerun.datatypes.TensorDimensionSelection")?;
143            if arrow_data.is_empty() {
144                Vec::new()
145            } else {
146                let (arrow_data_fields, arrow_data_arrays) =
147                    (arrow_data.fields(), arrow_data.columns());
148                let arrays_by_name: ::std::collections::HashMap<_, _> = arrow_data_fields
149                    .iter()
150                    .map(|field| field.name().as_str())
151                    .zip(arrow_data_arrays)
152                    .collect();
153                let dimension = {
154                    if !arrays_by_name.contains_key("dimension") {
155                        return Err(DeserializationError::missing_struct_field(
156                            Self::arrow_datatype(),
157                            "dimension",
158                        ))
159                        .with_context("rerun.datatypes.TensorDimensionSelection");
160                    }
161                    let arrow_data = &**arrays_by_name["dimension"];
162                    arrow_data
163                        .as_any()
164                        .downcast_ref::<UInt32Array>()
165                        .ok_or_else(|| {
166                            let expected = DataType::UInt32;
167                            let actual = arrow_data.data_type().clone();
168                            DeserializationError::datatype_mismatch(expected, actual)
169                        })
170                        .with_context("rerun.datatypes.TensorDimensionSelection#dimension")?
171                        .into_iter()
172                };
173                let invert = {
174                    if !arrays_by_name.contains_key("invert") {
175                        return Err(DeserializationError::missing_struct_field(
176                            Self::arrow_datatype(),
177                            "invert",
178                        ))
179                        .with_context("rerun.datatypes.TensorDimensionSelection");
180                    }
181                    let arrow_data = &**arrays_by_name["invert"];
182                    arrow_data
183                        .as_any()
184                        .downcast_ref::<BooleanArray>()
185                        .ok_or_else(|| {
186                            let expected = DataType::Boolean;
187                            let actual = arrow_data.data_type().clone();
188                            DeserializationError::datatype_mismatch(expected, actual)
189                        })
190                        .with_context("rerun.datatypes.TensorDimensionSelection#invert")?
191                        .into_iter()
192                };
193                ZipValidity::new_with_validity(
194                    ::itertools::izip!(dimension, invert),
195                    arrow_data.nulls(),
196                )
197                .map(|opt| {
198                    opt.map(|(dimension, invert)| {
199                        Ok(Self {
200                            dimension: dimension
201                                .ok_or_else(DeserializationError::missing_data)
202                                .with_context(
203                                    "rerun.datatypes.TensorDimensionSelection#dimension",
204                                )?,
205                            invert: invert
206                                .ok_or_else(DeserializationError::missing_data)
207                                .with_context("rerun.datatypes.TensorDimensionSelection#invert")?,
208                        })
209                    })
210                    .transpose()
211                })
212                .collect::<DeserializationResult<Vec<_>>>()
213                .with_context("rerun.datatypes.TensorDimensionSelection")?
214            }
215        })
216    }
217}
218
219impl ::re_byte_size::SizeBytes for TensorDimensionSelection {
220    #[inline]
221    fn heap_size_bytes(&self) -> u64 {
222        self.dimension.heap_size_bytes() + self.invert.heap_size_bytes()
223    }
224
225    #[inline]
226    fn is_pod() -> bool {
227        <u32>::is_pod() && <bool>::is_pod()
228    }
229}
re_types/datatypes/tensor_dimension_selection.rs

re_types/datatypes/
tensor_dimension_selection.rs
