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

re_types_core/datatypes/
time_range.rs
