re_types/blueprint/datatypes/
filter_by_range.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/blueprint/datatypes/filter_by_range.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**: Configuration for the filter-by-range feature of the dataframe view.
23///
24/// ⚠️ **This type is _unstable_ and may change significantly in a way that the data won't be backwards compatible.**
25#[derive(Clone, Debug, PartialEq, Eq)]
26pub struct FilterByRange {
27    /// Beginning of the time range.
28    pub start: crate::datatypes::TimeInt,
29
30    /// End of the time range (inclusive).
31    pub end: crate::datatypes::TimeInt,
32}
33
34::re_types_core::macros::impl_into_cow!(FilterByRange);
35
36impl ::re_types_core::Loggable for FilterByRange {
37    #[inline]
38    fn arrow_datatype() -> arrow::datatypes::DataType {
39        #![allow(clippy::wildcard_imports)]
40        use arrow::datatypes::*;
41        DataType::Struct(Fields::from(vec![
42            Field::new(
43                "start",
44                <crate::datatypes::TimeInt>::arrow_datatype(),
45                false,
46            ),
47            Field::new("end", <crate::datatypes::TimeInt>::arrow_datatype(), false),
48        ]))
49    }
50
51    fn to_arrow_opt<'a>(
52        data: impl IntoIterator<Item = Option<impl Into<::std::borrow::Cow<'a, Self>>>>,
53    ) -> SerializationResult<arrow::array::ArrayRef>
54    where
55        Self: Clone + 'a,
56    {
57        #![allow(clippy::wildcard_imports)]
58        #![allow(clippy::manual_is_variant_and)]
59        use ::re_types_core::{arrow_helpers::as_array_ref, Loggable as _, ResultExt as _};
60        use arrow::{array::*, buffer::*, datatypes::*};
61        Ok({
62            let fields = Fields::from(vec![
63                Field::new(
64                    "start",
65                    <crate::datatypes::TimeInt>::arrow_datatype(),
66                    false,
67                ),
68                Field::new("end", <crate::datatypes::TimeInt>::arrow_datatype(), false),
69            ]);
70            let (somes, data): (Vec<_>, Vec<_>) = data
71                .into_iter()
72                .map(|datum| {
73                    let datum: Option<::std::borrow::Cow<'a, Self>> = datum.map(Into::into);
74                    (datum.is_some(), datum)
75                })
76                .unzip();
77            let validity: Option<arrow::buffer::NullBuffer> = {
78                let any_nones = somes.iter().any(|some| !*some);
79                any_nones.then(|| somes.into())
80            };
81            as_array_ref(StructArray::new(
82                fields,
83                vec![
84                    {
85                        let (somes, start): (Vec<_>, Vec<_>) = data
86                            .iter()
87                            .map(|datum| {
88                                let datum = datum.as_ref().map(|datum| datum.start.clone());
89                                (datum.is_some(), datum)
90                            })
91                            .unzip();
92                        let start_validity: Option<arrow::buffer::NullBuffer> = {
93                            let any_nones = somes.iter().any(|some| !*some);
94                            any_nones.then(|| somes.into())
95                        };
96                        as_array_ref(PrimitiveArray::<Int64Type>::new(
97                            ScalarBuffer::from(
98                                start
99                                    .into_iter()
100                                    .map(|datum| datum.map(|datum| datum.0).unwrap_or_default())
101                                    .collect::<Vec<_>>(),
102                            ),
103                            start_validity,
104                        ))
105                    },
106                    {
107                        let (somes, end): (Vec<_>, Vec<_>) = data
108                            .iter()
109                            .map(|datum| {
110                                let datum = datum.as_ref().map(|datum| datum.end.clone());
111                                (datum.is_some(), datum)
112                            })
113                            .unzip();
114                        let end_validity: Option<arrow::buffer::NullBuffer> = {
115                            let any_nones = somes.iter().any(|some| !*some);
116                            any_nones.then(|| somes.into())
117                        };
118                        as_array_ref(PrimitiveArray::<Int64Type>::new(
119                            ScalarBuffer::from(
120                                end.into_iter()
121                                    .map(|datum| datum.map(|datum| datum.0).unwrap_or_default())
122                                    .collect::<Vec<_>>(),
123                            ),
124                            end_validity,
125                        ))
126                    },
127                ],
128                validity,
129            ))
130        })
131    }
132
133    fn from_arrow_opt(
134        arrow_data: &dyn arrow::array::Array,
135    ) -> DeserializationResult<Vec<Option<Self>>>
136    where
137        Self: Sized,
138    {
139        #![allow(clippy::wildcard_imports)]
140        use ::re_types_core::{arrow_zip_validity::ZipValidity, Loggable as _, ResultExt as _};
141        use arrow::{array::*, buffer::*, datatypes::*};
142        Ok({
143            let arrow_data = arrow_data
144                .as_any()
145                .downcast_ref::<arrow::array::StructArray>()
146                .ok_or_else(|| {
147                    let expected = Self::arrow_datatype();
148                    let actual = arrow_data.data_type().clone();
149                    DeserializationError::datatype_mismatch(expected, actual)
150                })
151                .with_context("rerun.blueprint.datatypes.FilterByRange")?;
152            if arrow_data.is_empty() {
153                Vec::new()
154            } else {
155                let (arrow_data_fields, arrow_data_arrays) =
156                    (arrow_data.fields(), arrow_data.columns());
157                let arrays_by_name: ::std::collections::HashMap<_, _> = arrow_data_fields
158                    .iter()
159                    .map(|field| field.name().as_str())
160                    .zip(arrow_data_arrays)
161                    .collect();
162                let start = {
163                    if !arrays_by_name.contains_key("start") {
164                        return Err(DeserializationError::missing_struct_field(
165                            Self::arrow_datatype(),
166                            "start",
167                        ))
168                        .with_context("rerun.blueprint.datatypes.FilterByRange");
169                    }
170                    let arrow_data = &**arrays_by_name["start"];
171                    arrow_data
172                        .as_any()
173                        .downcast_ref::<Int64Array>()
174                        .ok_or_else(|| {
175                            let expected = DataType::Int64;
176                            let actual = arrow_data.data_type().clone();
177                            DeserializationError::datatype_mismatch(expected, actual)
178                        })
179                        .with_context("rerun.blueprint.datatypes.FilterByRange#start")?
180                        .into_iter()
181                        .map(|res_or_opt| res_or_opt.map(crate::datatypes::TimeInt))
182                };
183                let end = {
184                    if !arrays_by_name.contains_key("end") {
185                        return Err(DeserializationError::missing_struct_field(
186                            Self::arrow_datatype(),
187                            "end",
188                        ))
189                        .with_context("rerun.blueprint.datatypes.FilterByRange");
190                    }
191                    let arrow_data = &**arrays_by_name["end"];
192                    arrow_data
193                        .as_any()
194                        .downcast_ref::<Int64Array>()
195                        .ok_or_else(|| {
196                            let expected = DataType::Int64;
197                            let actual = arrow_data.data_type().clone();
198                            DeserializationError::datatype_mismatch(expected, actual)
199                        })
200                        .with_context("rerun.blueprint.datatypes.FilterByRange#end")?
201                        .into_iter()
202                        .map(|res_or_opt| res_or_opt.map(crate::datatypes::TimeInt))
203                };
204                ZipValidity::new_with_validity(::itertools::izip!(start, end), arrow_data.nulls())
205                    .map(|opt| {
206                        opt.map(|(start, end)| {
207                            Ok(Self {
208                                start: start
209                                    .ok_or_else(DeserializationError::missing_data)
210                                    .with_context(
211                                        "rerun.blueprint.datatypes.FilterByRange#start",
212                                    )?,
213                                end: end
214                                    .ok_or_else(DeserializationError::missing_data)
215                                    .with_context("rerun.blueprint.datatypes.FilterByRange#end")?,
216                            })
217                        })
218                        .transpose()
219                    })
220                    .collect::<DeserializationResult<Vec<_>>>()
221                    .with_context("rerun.blueprint.datatypes.FilterByRange")?
222            }
223        })
224    }
225}
226
227impl ::re_byte_size::SizeBytes for FilterByRange {
228    #[inline]
229    fn heap_size_bytes(&self) -> u64 {
230        self.start.heap_size_bytes() + self.end.heap_size_bytes()
231    }
232
233    #[inline]
234    fn is_pod() -> bool {
235        <crate::datatypes::TimeInt>::is_pod() && <crate::datatypes::TimeInt>::is_pod()
236    }
237}
re_types/blueprint/datatypes/filter_by_range.rs

re_types/blueprint/datatypes/
filter_by_range.rs
