#![allow(unused_braces)]
#![allow(unused_imports)]
#![allow(unused_parens)]
#![allow(clippy::clone_on_copy)]
#![allow(clippy::cloned_instead_of_copied)]
#![allow(clippy::map_flatten)]
#![allow(clippy::needless_question_mark)]
#![allow(clippy::new_without_default)]
#![allow(clippy::redundant_closure)]
#![allow(clippy::too_many_arguments)]
#![allow(clippy::too_many_lines)]
use ::re_types_core::try_serialize_field;
use ::re_types_core::SerializationResult;
use ::re_types_core::{ComponentBatch as _, SerializedComponentBatch};
use ::re_types_core::{ComponentDescriptor, ComponentType};
use ::re_types_core::{DeserializationError, DeserializationResult};
#[derive(Clone, Debug, Default, PartialEq, Eq, PartialOrd, Ord)]
pub struct Utf8Pair {
pub first: crate::datatypes::Utf8,
pub second: crate::datatypes::Utf8,
}
::re_types_core::macros::impl_into_cow!(Utf8Pair);
impl ::re_types_core::Loggable for Utf8Pair {
#[inline]
fn arrow_datatype() -> arrow::datatypes::DataType {
#![allow(clippy::wildcard_imports)]
use arrow::datatypes::*;
DataType::Struct(Fields::from(vec![
Field::new("first", <crate::datatypes::Utf8>::arrow_datatype(), false),
Field::new("second", <crate::datatypes::Utf8>::arrow_datatype(), false),
]))
}
fn to_arrow_opt<'a>(
data: impl IntoIterator<Item = Option<impl Into<::std::borrow::Cow<'a, Self>>>>,
) -> SerializationResult<arrow::array::ArrayRef>
where
Self: Clone + 'a,
{
#![allow(clippy::wildcard_imports)]
#![allow(clippy::manual_is_variant_and)]
use ::re_types_core::{arrow_helpers::as_array_ref, Loggable as _, ResultExt as _};
use arrow::{array::*, buffer::*, datatypes::*};
Ok({
let fields = Fields::from(vec![
Field::new("first", <crate::datatypes::Utf8>::arrow_datatype(), false),
Field::new("second", <crate::datatypes::Utf8>::arrow_datatype(), false),
]);
let (somes, data): (Vec<_>, Vec<_>) = data
.into_iter()
.map(|datum| {
let datum: Option<::std::borrow::Cow<'a, Self>> = datum.map(Into::into);
(datum.is_some(), datum)
})
.unzip();
let validity: Option<arrow::buffer::NullBuffer> = {
let any_nones = somes.iter().any(|some| !*some);
any_nones.then(|| somes.into())
};
as_array_ref(StructArray::new(
fields,
vec![
{
let (somes, first): (Vec<_>, Vec<_>) = data
.iter()
.map(|datum| {
let datum = datum.as_ref().map(|datum| datum.first.clone());
(datum.is_some(), datum)
})
.unzip();
let first_validity: Option<arrow::buffer::NullBuffer> = {
let any_nones = somes.iter().any(|some| !*some);
any_nones.then(|| somes.into())
};
{
let offsets = arrow::buffer::OffsetBuffer::<i32>::from_lengths(
first.iter().map(|opt| {
opt.as_ref().map(|datum| datum.0.len()).unwrap_or_default()
}),
);
#[allow(clippy::unwrap_used)]
let capacity = offsets.last().copied().unwrap() as usize;
let mut buffer_builder =
arrow::array::builder::BufferBuilder::<u8>::new(capacity);
for data in first.iter().flatten() {
buffer_builder.append_slice(data.0.as_bytes());
}
let inner_data: arrow::buffer::Buffer = buffer_builder.finish();
#[allow(unsafe_code, clippy::undocumented_unsafe_blocks)]
as_array_ref(unsafe {
StringArray::new_unchecked(offsets, inner_data, first_validity)
})
}
},
{
let (somes, second): (Vec<_>, Vec<_>) = data
.iter()
.map(|datum| {
let datum = datum.as_ref().map(|datum| datum.second.clone());
(datum.is_some(), datum)
})
.unzip();
let second_validity: Option<arrow::buffer::NullBuffer> = {
let any_nones = somes.iter().any(|some| !*some);
any_nones.then(|| somes.into())
};
{
let offsets = arrow::buffer::OffsetBuffer::<i32>::from_lengths(
second.iter().map(|opt| {
opt.as_ref().map(|datum| datum.0.len()).unwrap_or_default()
}),
);
#[allow(clippy::unwrap_used)]
let capacity = offsets.last().copied().unwrap() as usize;
let mut buffer_builder =
arrow::array::builder::BufferBuilder::<u8>::new(capacity);
for data in second.iter().flatten() {
buffer_builder.append_slice(data.0.as_bytes());
}
let inner_data: arrow::buffer::Buffer = buffer_builder.finish();
#[allow(unsafe_code, clippy::undocumented_unsafe_blocks)]
as_array_ref(unsafe {
StringArray::new_unchecked(offsets, inner_data, second_validity)
})
}
},
],
validity,
))
})
}
fn from_arrow_opt(
arrow_data: &dyn arrow::array::Array,
) -> DeserializationResult<Vec<Option<Self>>>
where
Self: Sized,
{
#![allow(clippy::wildcard_imports)]
use ::re_types_core::{arrow_zip_validity::ZipValidity, Loggable as _, ResultExt as _};
use arrow::{array::*, buffer::*, datatypes::*};
Ok({
let arrow_data = arrow_data
.as_any()
.downcast_ref::<arrow::array::StructArray>()
.ok_or_else(|| {
let expected = Self::arrow_datatype();
let actual = arrow_data.data_type().clone();
DeserializationError::datatype_mismatch(expected, actual)
})
.with_context("rerun.datatypes.Utf8Pair")?;
if arrow_data.is_empty() {
Vec::new()
} else {
let (arrow_data_fields, arrow_data_arrays) =
(arrow_data.fields(), arrow_data.columns());
let arrays_by_name: ::std::collections::HashMap<_, _> = arrow_data_fields
.iter()
.map(|field| field.name().as_str())
.zip(arrow_data_arrays)
.collect();
let first = {
if !arrays_by_name.contains_key("first") {
return Err(DeserializationError::missing_struct_field(
Self::arrow_datatype(),
"first",
))
.with_context("rerun.datatypes.Utf8Pair");
}
let arrow_data = &**arrays_by_name["first"];
{
let arrow_data = arrow_data
.as_any()
.downcast_ref::<StringArray>()
.ok_or_else(|| {
let expected = DataType::Utf8;
let actual = arrow_data.data_type().clone();
DeserializationError::datatype_mismatch(expected, actual)
})
.with_context("rerun.datatypes.Utf8Pair#first")?;
let arrow_data_buf = arrow_data.values();
let offsets = arrow_data.offsets();
ZipValidity::new_with_validity(offsets.windows(2), arrow_data.nulls())
.map(|elem| {
elem.map(|window| {
let start = window[0] as usize;
let end = window[1] as usize;
let len = end - start;
if arrow_data_buf.len() < end {
return Err(DeserializationError::offset_slice_oob(
(start, end),
arrow_data_buf.len(),
));
}
#[allow(unsafe_code, clippy::undocumented_unsafe_blocks)]
let data = arrow_data_buf.slice_with_length(start, len);
Ok(data)
})
.transpose()
})
.map(|res_or_opt| {
res_or_opt.map(|res_or_opt| {
res_or_opt.map(|v| {
crate::datatypes::Utf8(::re_types_core::ArrowString::from(
v,
))
})
})
})
.collect::<DeserializationResult<Vec<Option<_>>>>()
.with_context("rerun.datatypes.Utf8Pair#first")?
.into_iter()
}
};
let second = {
if !arrays_by_name.contains_key("second") {
return Err(DeserializationError::missing_struct_field(
Self::arrow_datatype(),
"second",
))
.with_context("rerun.datatypes.Utf8Pair");
}
let arrow_data = &**arrays_by_name["second"];
{
let arrow_data = arrow_data
.as_any()
.downcast_ref::<StringArray>()
.ok_or_else(|| {
let expected = DataType::Utf8;
let actual = arrow_data.data_type().clone();
DeserializationError::datatype_mismatch(expected, actual)
})
.with_context("rerun.datatypes.Utf8Pair#second")?;
let arrow_data_buf = arrow_data.values();
let offsets = arrow_data.offsets();
ZipValidity::new_with_validity(offsets.windows(2), arrow_data.nulls())
.map(|elem| {
elem.map(|window| {
let start = window[0] as usize;
let end = window[1] as usize;
let len = end - start;
if arrow_data_buf.len() < end {
return Err(DeserializationError::offset_slice_oob(
(start, end),
arrow_data_buf.len(),
));
}
#[allow(unsafe_code, clippy::undocumented_unsafe_blocks)]
let data = arrow_data_buf.slice_with_length(start, len);
Ok(data)
})
.transpose()
})
.map(|res_or_opt| {
res_or_opt.map(|res_or_opt| {
res_or_opt.map(|v| {
crate::datatypes::Utf8(::re_types_core::ArrowString::from(
v,
))
})
})
})
.collect::<DeserializationResult<Vec<Option<_>>>>()
.with_context("rerun.datatypes.Utf8Pair#second")?
.into_iter()
}
};
ZipValidity::new_with_validity(
::itertools::izip!(first, second),
arrow_data.nulls(),
)
.map(|opt| {
opt.map(|(first, second)| {
Ok(Self {
first: first
.ok_or_else(DeserializationError::missing_data)
.with_context("rerun.datatypes.Utf8Pair#first")?,
second: second
.ok_or_else(DeserializationError::missing_data)
.with_context("rerun.datatypes.Utf8Pair#second")?,
})
})
.transpose()
})
.collect::<DeserializationResult<Vec<_>>>()
.with_context("rerun.datatypes.Utf8Pair")?
}
})
}
}
impl ::re_byte_size::SizeBytes for Utf8Pair {
#[inline]
fn heap_size_bytes(&self) -> u64 {
self.first.heap_size_bytes() + self.second.heap_size_bytes()
}
#[inline]
fn is_pod() -> bool {
<crate::datatypes::Utf8>::is_pod() && <crate::datatypes::Utf8>::is_pod()
}
}