#![allow(trivial_numeric_casts)]
#![allow(unused_imports)]
#![allow(unused_parens)]
#![allow(clippy::clone_on_copy)]
#![allow(clippy::cloned_instead_of_copied)]
#![allow(clippy::iter_on_single_items)]
#![allow(clippy::map_flatten)]
#![allow(clippy::match_wildcard_for_single_variants)]
#![allow(clippy::needless_question_mark)]
#![allow(clippy::new_without_default)]
#![allow(clippy::redundant_closure)]
#![allow(clippy::too_many_arguments)]
#![allow(clippy::too_many_lines)]
#![allow(clippy::unnecessary_cast)]
use ::re_types_core::external::arrow2;
use ::re_types_core::ComponentName;
use ::re_types_core::SerializationResult;
use ::re_types_core::{ComponentBatch, MaybeOwnedComponentBatch};
use ::re_types_core::{DeserializationError, DeserializationResult};
#[derive(Clone, Debug, Copy, PartialEq)]
pub enum Angle {
Radians(f32),
Degrees(f32),
}
impl ::re_types_core::SizeBytes for Angle {
#[allow(clippy::match_same_arms)]
#[inline]
fn heap_size_bytes(&self) -> u64 {
match self {
Self::Radians(v) => v.heap_size_bytes(),
Self::Degrees(v) => v.heap_size_bytes(),
}
}
#[inline]
fn is_pod() -> bool {
<f32>::is_pod() && <f32>::is_pod()
}
}
::re_types_core::macros::impl_into_cow!(Angle);
impl ::re_types_core::Loggable for Angle {
type Name = ::re_types_core::DatatypeName;
#[inline]
fn name() -> Self::Name {
"rerun.datatypes.Angle".into()
}
#[allow(clippy::wildcard_imports)]
#[inline]
fn arrow_datatype() -> arrow2::datatypes::DataType {
use arrow2::datatypes::*;
DataType::Union(
std::sync::Arc::new(vec![
Field::new("_null_markers", DataType::Null, true),
Field::new("Radians", DataType::Float32, false),
Field::new("Degrees", DataType::Float32, false),
]),
Some(std::sync::Arc::new(vec![0i32, 1i32, 2i32])),
UnionMode::Dense,
)
}
#[allow(clippy::wildcard_imports)]
fn to_arrow_opt<'a>(
data: impl IntoIterator<Item = Option<impl Into<::std::borrow::Cow<'a, Self>>>>,
) -> SerializationResult<Box<dyn arrow2::array::Array>>
where
Self: Clone + 'a,
{
use ::re_types_core::{Loggable as _, ResultExt as _};
use arrow2::{array::*, datatypes::*};
Ok({
let data: Vec<_> = data
.into_iter()
.map(|datum| {
let datum: Option<::std::borrow::Cow<'a, Self>> = datum.map(Into::into);
datum
})
.collect();
let types = data
.iter()
.map(|a| match a.as_deref() {
None => 0,
Some(Angle::Radians(_)) => 1i8,
Some(Angle::Degrees(_)) => 2i8,
})
.collect();
let fields = vec![
NullArray::new(DataType::Null, data.iter().filter(|v| v.is_none()).count()).boxed(),
{
let radians: Vec<_> = data
.iter()
.filter_map(|datum| match datum.as_deref() {
Some(Angle::Radians(v)) => Some(v.clone()),
_ => None,
})
.collect();
let radians_bitmap: Option<arrow2::bitmap::Bitmap> = None;
PrimitiveArray::new(
DataType::Float32,
radians.into_iter().collect(),
radians_bitmap,
)
.boxed()
},
{
let degrees: Vec<_> = data
.iter()
.filter_map(|datum| match datum.as_deref() {
Some(Angle::Degrees(v)) => Some(v.clone()),
_ => None,
})
.collect();
let degrees_bitmap: Option<arrow2::bitmap::Bitmap> = None;
PrimitiveArray::new(
DataType::Float32,
degrees.into_iter().collect(),
degrees_bitmap,
)
.boxed()
},
];
let offsets = Some({
let mut radians_offset = 0;
let mut degrees_offset = 0;
let mut nulls_offset = 0;
data.iter()
.map(|v| match v.as_deref() {
None => {
let offset = nulls_offset;
nulls_offset += 1;
offset
}
Some(Angle::Radians(_)) => {
let offset = radians_offset;
radians_offset += 1;
offset
}
Some(Angle::Degrees(_)) => {
let offset = degrees_offset;
degrees_offset += 1;
offset
}
})
.collect()
});
UnionArray::new(
<crate::datatypes::Angle>::arrow_datatype(),
types,
fields,
offsets,
)
.boxed()
})
}
#[allow(clippy::wildcard_imports)]
fn from_arrow_opt(
arrow_data: &dyn arrow2::array::Array,
) -> DeserializationResult<Vec<Option<Self>>>
where
Self: Sized,
{
use ::re_types_core::{Loggable as _, ResultExt as _};
use arrow2::{array::*, buffer::*, datatypes::*};
Ok({
let arrow_data = arrow_data
.as_any()
.downcast_ref::<arrow2::array::UnionArray>()
.ok_or_else(|| {
let expected = Self::arrow_datatype();
let actual = arrow_data.data_type().clone();
DeserializationError::datatype_mismatch(expected, actual)
})
.with_context("rerun.datatypes.Angle")?;
if arrow_data.is_empty() {
Vec::new()
} else {
let (arrow_data_types, arrow_data_arrays) =
(arrow_data.types(), arrow_data.fields());
let arrow_data_offsets = arrow_data
.offsets()
.ok_or_else(|| {
let expected = Self::arrow_datatype();
let actual = arrow_data.data_type().clone();
DeserializationError::datatype_mismatch(expected, actual)
})
.with_context("rerun.datatypes.Angle")?;
if arrow_data_types.len() != arrow_data_offsets.len() {
return Err(DeserializationError::offset_slice_oob(
(0, arrow_data_types.len()),
arrow_data_offsets.len(),
))
.with_context("rerun.datatypes.Angle");
}
let radians = {
if 1usize >= arrow_data_arrays.len() {
return Ok(Vec::new());
}
let arrow_data = &*arrow_data_arrays[1usize];
arrow_data
.as_any()
.downcast_ref::<Float32Array>()
.ok_or_else(|| {
let expected = DataType::Float32;
let actual = arrow_data.data_type().clone();
DeserializationError::datatype_mismatch(expected, actual)
})
.with_context("rerun.datatypes.Angle#Radians")?
.into_iter()
.map(|opt| opt.copied())
.collect::<Vec<_>>()
};
let degrees = {
if 2usize >= arrow_data_arrays.len() {
return Ok(Vec::new());
}
let arrow_data = &*arrow_data_arrays[2usize];
arrow_data
.as_any()
.downcast_ref::<Float32Array>()
.ok_or_else(|| {
let expected = DataType::Float32;
let actual = arrow_data.data_type().clone();
DeserializationError::datatype_mismatch(expected, actual)
})
.with_context("rerun.datatypes.Angle#Degrees")?
.into_iter()
.map(|opt| opt.copied())
.collect::<Vec<_>>()
};
arrow_data_types
.iter()
.enumerate()
.map(|(i, typ)| {
let offset = arrow_data_offsets[i];
if *typ == 0 {
Ok(None)
} else {
Ok(Some(match typ {
1i8 => Angle::Radians({
if offset as usize >= radians.len() {
return Err(DeserializationError::offset_oob(
offset as _,
radians.len(),
))
.with_context("rerun.datatypes.Angle#Radians");
}
#[allow(unsafe_code, clippy::undocumented_unsafe_blocks)]
unsafe { radians.get_unchecked(offset as usize) }
.clone()
.ok_or_else(DeserializationError::missing_data)
.with_context("rerun.datatypes.Angle#Radians")?
}),
2i8 => Angle::Degrees({
if offset as usize >= degrees.len() {
return Err(DeserializationError::offset_oob(
offset as _,
degrees.len(),
))
.with_context("rerun.datatypes.Angle#Degrees");
}
#[allow(unsafe_code, clippy::undocumented_unsafe_blocks)]
unsafe { degrees.get_unchecked(offset as usize) }
.clone()
.ok_or_else(DeserializationError::missing_data)
.with_context("rerun.datatypes.Angle#Degrees")?
}),
_ => {
return Err(DeserializationError::missing_union_arm(
Self::arrow_datatype(),
"<invalid>",
*typ as _,
));
}
}))
}
})
.collect::<DeserializationResult<Vec<_>>>()
.with_context("rerun.datatypes.Angle")?
}
})
}
}