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

re_types/blueprint/datatypes/
filter_by_range.rs
