re_types_core/datatypes/
time_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/datatypes/visible_time_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 crate::try_serialize_field;
16use crate::SerializationResult;
17use crate::{ComponentBatch as _, SerializedComponentBatch};
18use crate::{ComponentDescriptor, ComponentName};
19use crate::{DeserializationError, DeserializationResult};
20
21/// **Datatype**: Visible time range bounds for a specific timeline.
22#[derive(Clone, Debug, PartialEq, Eq)]
23pub struct TimeRange {
24    /// Low time boundary for sequence timeline.
25    pub start: crate::datatypes::TimeRangeBoundary,
26
27    /// High time boundary for sequence timeline.
28    pub end: crate::datatypes::TimeRangeBoundary,
29}
30
31crate::macros::impl_into_cow!(TimeRange);
32
33impl crate::Loggable for TimeRange {
34    #[inline]
35    fn arrow_datatype() -> arrow::datatypes::DataType {
36        #![allow(clippy::wildcard_imports)]
37        use arrow::datatypes::*;
38        DataType::Struct(Fields::from(vec![
39            Field::new(
40                "start",
41                <crate::datatypes::TimeRangeBoundary>::arrow_datatype(),
42                true,
43            ),
44            Field::new(
45                "end",
46                <crate::datatypes::TimeRangeBoundary>::arrow_datatype(),
47                true,
48            ),
49        ]))
50    }
51
52    fn to_arrow_opt<'a>(
53        data: impl IntoIterator<Item = Option<impl Into<::std::borrow::Cow<'a, Self>>>>,
54    ) -> SerializationResult<arrow::array::ArrayRef>
55    where
56        Self: Clone + 'a,
57    {
58        #![allow(clippy::wildcard_imports)]
59        #![allow(clippy::manual_is_variant_and)]
60        use crate::{arrow_helpers::as_array_ref, Loggable as _, ResultExt as _};
61        use arrow::{array::*, buffer::*, datatypes::*};
62        Ok({
63            let fields = Fields::from(vec![
64                Field::new(
65                    "start",
66                    <crate::datatypes::TimeRangeBoundary>::arrow_datatype(),
67                    true,
68                ),
69                Field::new(
70                    "end",
71                    <crate::datatypes::TimeRangeBoundary>::arrow_datatype(),
72                    true,
73                ),
74            ]);
75            let (somes, data): (Vec<_>, Vec<_>) = data
76                .into_iter()
77                .map(|datum| {
78                    let datum: Option<::std::borrow::Cow<'a, Self>> = datum.map(Into::into);
79                    (datum.is_some(), datum)
80                })
81                .unzip();
82            let 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(StructArray::new(
87                fields,
88                vec![
89                    {
90                        let (somes, start): (Vec<_>, Vec<_>) = data
91                            .iter()
92                            .map(|datum| {
93                                let datum = datum.as_ref().map(|datum| datum.start.clone());
94                                (datum.is_some(), datum)
95                            })
96                            .unzip();
97                        let start_validity: Option<arrow::buffer::NullBuffer> = {
98                            let any_nones = somes.iter().any(|some| !*some);
99                            any_nones.then(|| somes.into())
100                        };
101                        {
102                            _ = start_validity;
103                            crate::datatypes::TimeRangeBoundary::to_arrow_opt(start)?
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                        {
119                            _ = end_validity;
120                            crate::datatypes::TimeRangeBoundary::to_arrow_opt(end)?
121                        }
122                    },
123                ],
124                validity,
125            ))
126        })
127    }
128
129    fn from_arrow_opt(
130        arrow_data: &dyn arrow::array::Array,
131    ) -> DeserializationResult<Vec<Option<Self>>>
132    where
133        Self: Sized,
134    {
135        #![allow(clippy::wildcard_imports)]
136        use crate::{arrow_zip_validity::ZipValidity, Loggable as _, ResultExt as _};
137        use arrow::{array::*, buffer::*, datatypes::*};
138        Ok({
139            let arrow_data = arrow_data
140                .as_any()
141                .downcast_ref::<arrow::array::StructArray>()
142                .ok_or_else(|| {
143                    let expected = Self::arrow_datatype();
144                    let actual = arrow_data.data_type().clone();
145                    DeserializationError::datatype_mismatch(expected, actual)
146                })
147                .with_context("rerun.datatypes.TimeRange")?;
148            if arrow_data.is_empty() {
149                Vec::new()
150            } else {
151                let (arrow_data_fields, arrow_data_arrays) =
152                    (arrow_data.fields(), arrow_data.columns());
153                let arrays_by_name: ::std::collections::HashMap<_, _> = arrow_data_fields
154                    .iter()
155                    .map(|field| field.name().as_str())
156                    .zip(arrow_data_arrays)
157                    .collect();
158                let start = {
159                    if !arrays_by_name.contains_key("start") {
160                        return Err(DeserializationError::missing_struct_field(
161                            Self::arrow_datatype(),
162                            "start",
163                        ))
164                        .with_context("rerun.datatypes.TimeRange");
165                    }
166                    let arrow_data = &**arrays_by_name["start"];
167                    crate::datatypes::TimeRangeBoundary::from_arrow_opt(arrow_data)
168                        .with_context("rerun.datatypes.TimeRange#start")?
169                        .into_iter()
170                };
171                let end = {
172                    if !arrays_by_name.contains_key("end") {
173                        return Err(DeserializationError::missing_struct_field(
174                            Self::arrow_datatype(),
175                            "end",
176                        ))
177                        .with_context("rerun.datatypes.TimeRange");
178                    }
179                    let arrow_data = &**arrays_by_name["end"];
180                    crate::datatypes::TimeRangeBoundary::from_arrow_opt(arrow_data)
181                        .with_context("rerun.datatypes.TimeRange#end")?
182                        .into_iter()
183                };
184                ZipValidity::new_with_validity(::itertools::izip!(start, end), arrow_data.nulls())
185                    .map(|opt| {
186                        opt.map(|(start, end)| {
187                            Ok(Self {
188                                start: start
189                                    .ok_or_else(DeserializationError::missing_data)
190                                    .with_context("rerun.datatypes.TimeRange#start")?,
191                                end: end
192                                    .ok_or_else(DeserializationError::missing_data)
193                                    .with_context("rerun.datatypes.TimeRange#end")?,
194                            })
195                        })
196                        .transpose()
197                    })
198                    .collect::<DeserializationResult<Vec<_>>>()
199                    .with_context("rerun.datatypes.TimeRange")?
200            }
201        })
202    }
203}
204
205impl ::re_byte_size::SizeBytes for TimeRange {
206    #[inline]
207    fn heap_size_bytes(&self) -> u64 {
208        self.start.heap_size_bytes() + self.end.heap_size_bytes()
209    }
210
211    #[inline]
212    fn is_pod() -> bool {
213        <crate::datatypes::TimeRangeBoundary>::is_pod()
214            && <crate::datatypes::TimeRangeBoundary>::is_pod()
215    }
216}
re_types_core/datatypes/time_range.rs

re_types_core/datatypes/
time_range.rs
