diff --git a/Cargo.toml b/Cargo.toml index be3829c..c683b79 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -6,17 +6,20 @@ license = "Apache-2.0" homepage = "https://github.com/DataEngineeringLabs/arrow-format" repository = "https://github.com/DataEngineeringLabs/arrow-format" authors = ["Jorge C. Leitao "] -keywords = [ "arrow", "analytics" ] +keywords = ["arrow", "analytics"] description = "Unofficial flatbuffers and tonic code of Apache Arrow spec" # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html [dependencies] planus = { version = "0.3.1", optional = true } -serde = { version = "1", optional = true, default-features = false, features = ["derive", "std"] } -tonic = { version = "0.8.0", optional = true } -prost = { version = "0.11.0", optional = true } -prost-derive = { version = "0.11.0", optional = true } +serde = { version = "1", optional = true, default-features = false, features = [ + "derive", + "std", +] } +tonic = { version = "0.9", optional = true } +prost = { version = "0.11", optional = true } +prost-derive = { version = "0.11", optional = true } [features] default = [] diff --git a/src/flight/service.rs b/src/flight/service.rs index 6032ca4..61ad41e 100644 --- a/src/flight/service.rs +++ b/src/flight/service.rs @@ -67,6 +67,21 @@ pub mod flight_service_client { self.inner = self.inner.send_compressed(encoding); self } + + /// Limits the maximum size of a decoded message. + #[must_use] + pub fn max_decoding_message_size(mut self, limit: usize) -> Self { + self.inner = self.inner.max_decoding_message_size(limit); + self + } + + /// Limits the maximum size of an encoded message. + #[must_use] + pub fn max_encoding_message_size(mut self, limit: usize) -> Self { + self.inner = self.inner.max_encoding_message_size(limit); + self + } + /// Enable decompressing responses. #[must_use] pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self { @@ -434,6 +449,8 @@ pub mod flight_service_server { inner: _Inner, accept_compression_encodings: EnabledCompressionEncodings, send_compression_encodings: EnabledCompressionEncodings, + max_decoding_message_size: Option, + max_encoding_message_size: Option, } struct _Inner(Arc); impl FlightServiceServer { @@ -446,6 +463,8 @@ pub mod flight_service_server { inner, accept_compression_encodings: Default::default(), send_compression_encodings: Default::default(), + max_decoding_message_size: None, + max_encoding_message_size: None, } } pub fn with_interceptor(inner: T, interceptor: F) -> InterceptedService @@ -466,6 +485,20 @@ pub mod flight_service_server { self.send_compression_encodings.enable(encoding); self } + + /// Limits the maximum size of a decoded message. + #[must_use] + pub fn max_decoding_message_size(mut self, limit: usize) -> Self { + self.max_decoding_message_size = Some(limit); + self + } + + /// Limits the maximum size of an encoded message. + #[must_use] + pub fn max_encoding_message_size(mut self, limit: usize) -> Self { + self.max_encoding_message_size = Some(limit); + self + } } impl tonic::codegen::Service> for FlightServiceServer where @@ -503,6 +536,8 @@ pub mod flight_service_server { } let accept_compression_encodings = self.accept_compression_encodings; let send_compression_encodings = self.send_compression_encodings; + let max_decoding_message_size = self.max_decoding_message_size; + let max_encoding_message_size = self.max_encoding_message_size; let inner = self.inner.clone(); let fut = async move { let inner = inner.0; @@ -511,6 +546,9 @@ pub mod flight_service_server { let mut grpc = tonic::server::Grpc::new(codec).apply_compression_config( accept_compression_encodings, send_compression_encodings, + ).apply_max_message_size_config( + max_decoding_message_size, + max_encoding_message_size, ); let res = grpc.streaming(method, req).await; Ok(res) @@ -538,6 +576,8 @@ pub mod flight_service_server { } let accept_compression_encodings = self.accept_compression_encodings; let send_compression_encodings = self.send_compression_encodings; + let max_decoding_message_size = self.max_decoding_message_size; + let max_encoding_message_size = self.max_encoding_message_size; let inner = self.inner.clone(); let fut = async move { let inner = inner.0; @@ -546,6 +586,9 @@ pub mod flight_service_server { let mut grpc = tonic::server::Grpc::new(codec).apply_compression_config( accept_compression_encodings, send_compression_encodings, + ).apply_max_message_size_config( + max_decoding_message_size, + max_encoding_message_size, ); let res = grpc.server_streaming(method, req).await; Ok(res) @@ -571,6 +614,8 @@ pub mod flight_service_server { } let accept_compression_encodings = self.accept_compression_encodings; let send_compression_encodings = self.send_compression_encodings; + let max_decoding_message_size = self.max_decoding_message_size; + let max_encoding_message_size = self.max_encoding_message_size; let inner = self.inner.clone(); let fut = async move { let inner = inner.0; @@ -579,6 +624,9 @@ pub mod flight_service_server { let mut grpc = tonic::server::Grpc::new(codec).apply_compression_config( accept_compression_encodings, send_compression_encodings, + ).apply_max_message_size_config( + max_decoding_message_size, + max_encoding_message_size, ); let res = grpc.unary(method, req).await; Ok(res) @@ -602,6 +650,8 @@ pub mod flight_service_server { } let accept_compression_encodings = self.accept_compression_encodings; let send_compression_encodings = self.send_compression_encodings; + let max_decoding_message_size = self.max_decoding_message_size; + let max_encoding_message_size = self.max_encoding_message_size; let inner = self.inner.clone(); let fut = async move { let inner = inner.0; @@ -610,6 +660,9 @@ pub mod flight_service_server { let mut grpc = tonic::server::Grpc::new(codec).apply_compression_config( accept_compression_encodings, send_compression_encodings, + ).apply_max_message_size_config( + max_decoding_message_size, + max_encoding_message_size, ); let res = grpc.unary(method, req).await; Ok(res) @@ -632,6 +685,8 @@ pub mod flight_service_server { } let accept_compression_encodings = self.accept_compression_encodings; let send_compression_encodings = self.send_compression_encodings; + let max_decoding_message_size = self.max_decoding_message_size; + let max_encoding_message_size = self.max_encoding_message_size; let inner = self.inner.clone(); let fut = async move { let inner = inner.0; @@ -640,6 +695,9 @@ pub mod flight_service_server { let mut grpc = tonic::server::Grpc::new(codec).apply_compression_config( accept_compression_encodings, send_compression_encodings, + ).apply_max_message_size_config( + max_decoding_message_size, + max_encoding_message_size, ); let res = grpc.server_streaming(method, req).await; Ok(res) @@ -665,6 +723,8 @@ pub mod flight_service_server { } let accept_compression_encodings = self.accept_compression_encodings; let send_compression_encodings = self.send_compression_encodings; + let max_decoding_message_size = self.max_decoding_message_size; + let max_encoding_message_size = self.max_encoding_message_size; let inner = self.inner.clone(); let fut = async move { let inner = inner.0; @@ -673,6 +733,9 @@ pub mod flight_service_server { let mut grpc = tonic::server::Grpc::new(codec).apply_compression_config( accept_compression_encodings, send_compression_encodings, + ).apply_max_message_size_config( + max_decoding_message_size, + max_encoding_message_size, ); let res = grpc.streaming(method, req).await; Ok(res) @@ -698,6 +761,8 @@ pub mod flight_service_server { } let accept_compression_encodings = self.accept_compression_encodings; let send_compression_encodings = self.send_compression_encodings; + let max_decoding_message_size = self.max_decoding_message_size; + let max_encoding_message_size = self.max_encoding_message_size; let inner = self.inner.clone(); let fut = async move { let inner = inner.0; @@ -706,6 +771,9 @@ pub mod flight_service_server { let mut grpc = tonic::server::Grpc::new(codec).apply_compression_config( accept_compression_encodings, send_compression_encodings, + ).apply_max_message_size_config( + max_decoding_message_size, + max_encoding_message_size, ); let res = grpc.streaming(method, req).await; Ok(res) @@ -728,6 +796,8 @@ pub mod flight_service_server { } let accept_compression_encodings = self.accept_compression_encodings; let send_compression_encodings = self.send_compression_encodings; + let max_decoding_message_size = self.max_decoding_message_size; + let max_encoding_message_size = self.max_encoding_message_size; let inner = self.inner.clone(); let fut = async move { let inner = inner.0; @@ -736,6 +806,9 @@ pub mod flight_service_server { let mut grpc = tonic::server::Grpc::new(codec).apply_compression_config( accept_compression_encodings, send_compression_encodings, + ).apply_max_message_size_config( + max_decoding_message_size, + max_encoding_message_size, ); let res = grpc.server_streaming(method, req).await; Ok(res) @@ -758,6 +831,8 @@ pub mod flight_service_server { } let accept_compression_encodings = self.accept_compression_encodings; let send_compression_encodings = self.send_compression_encodings; + let max_decoding_message_size = self.max_decoding_message_size; + let max_encoding_message_size = self.max_encoding_message_size; let inner = self.inner.clone(); let fut = async move { let inner = inner.0; @@ -766,6 +841,9 @@ pub mod flight_service_server { let mut grpc = tonic::server::Grpc::new(codec).apply_compression_config( accept_compression_encodings, send_compression_encodings, + ).apply_max_message_size_config( + max_decoding_message_size, + max_encoding_message_size, ); let res = grpc.server_streaming(method, req).await; Ok(res) @@ -790,6 +868,8 @@ pub mod flight_service_server { inner, accept_compression_encodings: self.accept_compression_encodings, send_compression_encodings: self.send_compression_encodings, + max_decoding_message_size: self.max_decoding_message_size, + max_encoding_message_size: self.max_encoding_message_size, } } } diff --git a/src/ipc/generated.rs b/src/ipc/generated.rs index a21908c..1f96ab0 100644 --- a/src/ipc/generated.rs +++ b/src/ipc/generated.rs @@ -1,11 +1,24 @@ pub use root::*; + +const _: () = ::planus::check_version_compatibility("planus-0.3.1"); + #[no_implicit_prelude] mod root { pub mod org { pub mod apache { pub mod arrow { pub mod flatbuf { - #[derive(Clone, Debug, PartialEq, ::serde::Serialize, ::serde::Deserialize)] + #[derive( + Clone, + Debug, + PartialEq, + PartialOrd, + Eq, + Ord, + Hash, + ::serde::Serialize, + ::serde::Deserialize, + )] pub struct Footer { pub version: self::MetadataVersion, pub schema: @@ -18,35 +31,48 @@ mod root { ::core::option::Option<::planus::alloc::vec::Vec>, } + #[allow(clippy::derivable_impls)] + impl ::core::default::Default for Footer { + fn default() -> Self { + Self { + version: self::MetadataVersion::V1, + schema: ::core::default::Default::default(), + dictionaries: ::core::default::Default::default(), + record_batches: ::core::default::Default::default(), + custom_metadata: ::core::default::Default::default(), + } + } + } + impl Footer { #[allow(clippy::too_many_arguments)] pub fn create( builder: &mut ::planus::Builder, - version: impl ::planus::WriteAsDefault< + field_version: impl ::planus::WriteAsDefault< self::MetadataVersion, self::MetadataVersion, >, - schema: impl ::planus::WriteAsOptional<::planus::Offset>, - dictionaries: impl ::planus::WriteAsOptional< + field_schema: impl ::planus::WriteAsOptional<::planus::Offset>, + field_dictionaries: impl ::planus::WriteAsOptional< ::planus::Offset<[self::Block]>, >, - record_batches: impl ::planus::WriteAsOptional< + field_record_batches: impl ::planus::WriteAsOptional< ::planus::Offset<[self::Block]>, >, - custom_metadata: impl ::planus::WriteAsOptional< + field_custom_metadata: impl ::planus::WriteAsOptional< ::planus::Offset<[::planus::Offset]>, >, ) -> ::planus::Offset { let prepared_version = - version.prepare(builder, &self::MetadataVersion::V1); + field_version.prepare(builder, &self::MetadataVersion::V1); - let prepared_schema = schema.prepare(builder); + let prepared_schema = field_schema.prepare(builder); - let prepared_dictionaries = dictionaries.prepare(builder); + let prepared_dictionaries = field_dictionaries.prepare(builder); - let prepared_record_batches = record_batches.prepare(builder); + let prepared_record_batches = field_record_batches.prepare(builder); - let prepared_custom_metadata = custom_metadata.prepare(builder); + let prepared_custom_metadata = field_custom_metadata.prepare(builder); let mut table_writer = ::planus::table_writer::TableWriter::<12, 18>::new(builder); @@ -192,24 +218,25 @@ mod root { fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { let mut f = f.debug_struct("FooterRef"); f.field("version", &self.version()); - if let ::core::option::Option::Some(schema) = self.schema().transpose() + if let ::core::option::Option::Some(field_schema) = + self.schema().transpose() { - f.field("schema", &schema); + f.field("schema", &field_schema); } - if let ::core::option::Option::Some(dictionaries) = + if let ::core::option::Option::Some(field_dictionaries) = self.dictionaries().transpose() { - f.field("dictionaries", &dictionaries); + f.field("dictionaries", &field_dictionaries); } - if let ::core::option::Option::Some(record_batches) = + if let ::core::option::Option::Some(field_record_batches) = self.record_batches().transpose() { - f.field("record_batches", &record_batches); + f.field("record_batches", &field_record_batches); } - if let ::core::option::Option::Some(custom_metadata) = + if let ::core::option::Option::Some(field_custom_metadata) = self.custom_metadata().transpose() { - f.field("custom_metadata", &custom_metadata); + f.field("custom_metadata", &field_custom_metadata); } f.finish() } @@ -328,7 +355,17 @@ mod root { } #[derive( - Copy, Clone, Debug, PartialEq, ::serde::Serialize, ::serde::Deserialize, + Copy, + Clone, + Debug, + PartialEq, + PartialOrd, + Eq, + Ord, + Hash, + Default, + ::serde::Serialize, + ::serde::Deserialize, )] pub struct Block { pub offset: i64, @@ -359,6 +396,29 @@ mod root { } } + impl ::planus::WriteAsOffset for Block { + fn prepare( + &self, + builder: &mut ::planus::Builder, + ) -> ::planus::Offset { + unsafe { + builder.write_with(24, 8, |buffer_position, bytes| { + let bytes = bytes.as_mut_ptr(); + + ::planus::WriteAsPrimitive::write( + self, + ::planus::Cursor::new( + &mut *(bytes + as *mut [::core::mem::MaybeUninit; 24]), + ), + buffer_position, + ); + }); + } + builder.current_offset() + } + } + impl ::planus::WriteAs for Block { type Prepared = Self; fn prepare(&self, _builder: &mut ::planus::Builder) -> Self { @@ -471,7 +531,16 @@ mod root { } #[derive( - Copy, Clone, Debug, PartialEq, Eq, ::serde::Serialize, ::serde::Deserialize, + Copy, + Clone, + Debug, + PartialEq, + Eq, + PartialOrd, + Ord, + Hash, + ::serde::Serialize, + ::serde::Deserialize, )] #[repr(i16)] pub enum MetadataVersion { @@ -596,12 +665,12 @@ mod root { } } - impl<'buf> ::planus::VectorWrite for MetadataVersion { + impl ::planus::VectorWrite for MetadataVersion { const STRIDE: usize = 2; type Value = Self; - fn prepare(&self, _builder: &mut ::planus::Builder) -> Self::Value { + fn prepare(&self, _builder: &mut ::planus::Builder) -> Self { *self } @@ -623,7 +692,16 @@ mod root { } #[derive( - Copy, Clone, Debug, PartialEq, Eq, ::serde::Serialize, ::serde::Deserialize, + Copy, + Clone, + Debug, + PartialEq, + Eq, + PartialOrd, + Ord, + Hash, + ::serde::Serialize, + ::serde::Deserialize, )] #[repr(i64)] pub enum Feature { @@ -744,12 +822,12 @@ mod root { } } - impl<'buf> ::planus::VectorWrite for Feature { + impl ::planus::VectorWrite for Feature { const STRIDE: usize = 8; type Value = Self; - fn prepare(&self, _builder: &mut ::planus::Builder) -> Self::Value { + fn prepare(&self, _builder: &mut ::planus::Builder) -> Self { *self } @@ -770,9 +848,26 @@ mod root { } } - #[derive(Clone, Debug, PartialEq, ::serde::Serialize, ::serde::Deserialize)] + #[derive( + Clone, + Debug, + PartialEq, + PartialOrd, + Eq, + Ord, + Hash, + ::serde::Serialize, + ::serde::Deserialize, + )] pub struct Null {} + #[allow(clippy::derivable_impls)] + impl ::core::default::Default for Null { + fn default() -> Self { + Self {} + } + } + impl Null { #[allow(clippy::too_many_arguments)] pub fn create(builder: &mut ::planus::Builder) -> ::planus::Offset { @@ -909,9 +1004,26 @@ mod root { } } - #[derive(Clone, Debug, PartialEq, ::serde::Serialize, ::serde::Deserialize)] + #[derive( + Clone, + Debug, + PartialEq, + PartialOrd, + Eq, + Ord, + Hash, + ::serde::Serialize, + ::serde::Deserialize, + )] pub struct Struct {} + #[allow(clippy::derivable_impls)] + impl ::core::default::Default for Struct { + fn default() -> Self { + Self {} + } + } + impl Struct { #[allow(clippy::too_many_arguments)] pub fn create(builder: &mut ::planus::Builder) -> ::planus::Offset { @@ -1048,9 +1160,26 @@ mod root { } } - #[derive(Clone, Debug, PartialEq, ::serde::Serialize, ::serde::Deserialize)] + #[derive( + Clone, + Debug, + PartialEq, + PartialOrd, + Eq, + Ord, + Hash, + ::serde::Serialize, + ::serde::Deserialize, + )] pub struct List {} + #[allow(clippy::derivable_impls)] + impl ::core::default::Default for List { + fn default() -> Self { + Self {} + } + } + impl List { #[allow(clippy::too_many_arguments)] pub fn create(builder: &mut ::planus::Builder) -> ::planus::Offset { @@ -1187,9 +1316,26 @@ mod root { } } - #[derive(Clone, Debug, PartialEq, ::serde::Serialize, ::serde::Deserialize)] + #[derive( + Clone, + Debug, + PartialEq, + PartialOrd, + Eq, + Ord, + Hash, + ::serde::Serialize, + ::serde::Deserialize, + )] pub struct LargeList {} + #[allow(clippy::derivable_impls)] + impl ::core::default::Default for LargeList { + fn default() -> Self { + Self {} + } + } + impl LargeList { #[allow(clippy::too_many_arguments)] pub fn create(builder: &mut ::planus::Builder) -> ::planus::Offset { @@ -1326,18 +1472,35 @@ mod root { } } - #[derive(Clone, Debug, PartialEq, ::serde::Serialize, ::serde::Deserialize)] + #[derive( + Clone, + Debug, + PartialEq, + PartialOrd, + Eq, + Ord, + Hash, + ::serde::Serialize, + ::serde::Deserialize, + )] pub struct FixedSizeList { pub list_size: i32, } + #[allow(clippy::derivable_impls)] + impl ::core::default::Default for FixedSizeList { + fn default() -> Self { + Self { list_size: 0 } + } + } + impl FixedSizeList { #[allow(clippy::too_many_arguments)] pub fn create( builder: &mut ::planus::Builder, - list_size: impl ::planus::WriteAsDefault, + field_list_size: impl ::planus::WriteAsDefault, ) -> ::planus::Offset { - let prepared_list_size = list_size.prepare(builder, &0); + let prepared_list_size = field_list_size.prepare(builder, &0); let mut table_writer = ::planus::table_writer::TableWriter::<4, 4>::new(builder); @@ -1497,18 +1660,35 @@ mod root { } } - #[derive(Clone, Debug, PartialEq, ::serde::Serialize, ::serde::Deserialize)] + #[derive( + Clone, + Debug, + PartialEq, + PartialOrd, + Eq, + Ord, + Hash, + ::serde::Serialize, + ::serde::Deserialize, + )] pub struct Map { pub keys_sorted: bool, } + #[allow(clippy::derivable_impls)] + impl ::core::default::Default for Map { + fn default() -> Self { + Self { keys_sorted: false } + } + } + impl Map { #[allow(clippy::too_many_arguments)] pub fn create( builder: &mut ::planus::Builder, - keys_sorted: impl ::planus::WriteAsDefault, + field_keys_sorted: impl ::planus::WriteAsDefault, ) -> ::planus::Offset { - let prepared_keys_sorted = keys_sorted.prepare(builder, &false); + let prepared_keys_sorted = field_keys_sorted.prepare(builder, &false); let mut table_writer = ::planus::table_writer::TableWriter::<4, 1>::new(builder); @@ -1666,7 +1846,16 @@ mod root { } #[derive( - Copy, Clone, Debug, PartialEq, Eq, ::serde::Serialize, ::serde::Deserialize, + Copy, + Clone, + Debug, + PartialEq, + Eq, + PartialOrd, + Ord, + Hash, + ::serde::Serialize, + ::serde::Deserialize, )] #[repr(i16)] pub enum UnionMode { @@ -1785,12 +1974,12 @@ mod root { } } - impl<'buf> ::planus::VectorWrite for UnionMode { + impl ::planus::VectorWrite for UnionMode { const STRIDE: usize = 2; type Value = Self; - fn prepare(&self, _builder: &mut ::planus::Builder) -> Self::Value { + fn prepare(&self, _builder: &mut ::planus::Builder) -> Self { *self } @@ -1811,22 +2000,43 @@ mod root { } } - #[derive(Clone, Debug, PartialEq, ::serde::Serialize, ::serde::Deserialize)] + #[derive( + Clone, + Debug, + PartialEq, + PartialOrd, + Eq, + Ord, + Hash, + ::serde::Serialize, + ::serde::Deserialize, + )] pub struct Union { pub mode: self::UnionMode, pub type_ids: ::core::option::Option<::planus::alloc::vec::Vec>, } + #[allow(clippy::derivable_impls)] + impl ::core::default::Default for Union { + fn default() -> Self { + Self { + mode: self::UnionMode::Sparse, + type_ids: ::core::default::Default::default(), + } + } + } + impl Union { #[allow(clippy::too_many_arguments)] pub fn create( builder: &mut ::planus::Builder, - mode: impl ::planus::WriteAsDefault, - type_ids: impl ::planus::WriteAsOptional<::planus::Offset<[i32]>>, + field_mode: impl ::planus::WriteAsDefault, + field_type_ids: impl ::planus::WriteAsOptional<::planus::Offset<[i32]>>, ) -> ::planus::Offset { - let prepared_mode = mode.prepare(builder, &self::UnionMode::Sparse); + let prepared_mode = + field_mode.prepare(builder, &self::UnionMode::Sparse); - let prepared_type_ids = type_ids.prepare(builder); + let prepared_type_ids = field_type_ids.prepare(builder); let mut table_writer = ::planus::table_writer::TableWriter::<6, 6>::new(builder); @@ -1913,10 +2123,10 @@ mod root { fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { let mut f = f.debug_struct("UnionRef"); f.field("mode", &self.mode()); - if let ::core::option::Option::Some(type_ids) = + if let ::core::option::Option::Some(field_type_ids) = self.type_ids().transpose() { - f.field("type_ids", &type_ids); + f.field("type_ids", &field_type_ids); } f.finish() } @@ -2009,22 +2219,42 @@ mod root { } } - #[derive(Clone, Debug, PartialEq, ::serde::Serialize, ::serde::Deserialize)] + #[derive( + Clone, + Debug, + PartialEq, + PartialOrd, + Eq, + Ord, + Hash, + ::serde::Serialize, + ::serde::Deserialize, + )] pub struct Int { pub bit_width: i32, pub is_signed: bool, } + #[allow(clippy::derivable_impls)] + impl ::core::default::Default for Int { + fn default() -> Self { + Self { + bit_width: 0, + is_signed: false, + } + } + } + impl Int { #[allow(clippy::too_many_arguments)] pub fn create( builder: &mut ::planus::Builder, - bit_width: impl ::planus::WriteAsDefault, - is_signed: impl ::planus::WriteAsDefault, + field_bit_width: impl ::planus::WriteAsDefault, + field_is_signed: impl ::planus::WriteAsDefault, ) -> ::planus::Offset { - let prepared_bit_width = bit_width.prepare(builder, &0); + let prepared_bit_width = field_bit_width.prepare(builder, &0); - let prepared_is_signed = is_signed.prepare(builder, &false); + let prepared_is_signed = field_is_signed.prepare(builder, &false); let mut table_writer = ::planus::table_writer::TableWriter::<6, 5>::new(builder); @@ -2196,7 +2426,16 @@ mod root { } #[derive( - Copy, Clone, Debug, PartialEq, Eq, ::serde::Serialize, ::serde::Deserialize, + Copy, + Clone, + Debug, + PartialEq, + Eq, + PartialOrd, + Ord, + Hash, + ::serde::Serialize, + ::serde::Deserialize, )] #[repr(i16)] pub enum Precision { @@ -2317,12 +2556,12 @@ mod root { } } - impl<'buf> ::planus::VectorWrite for Precision { + impl ::planus::VectorWrite for Precision { const STRIDE: usize = 2; type Value = Self; - fn prepare(&self, _builder: &mut ::planus::Builder) -> Self::Value { + fn prepare(&self, _builder: &mut ::planus::Builder) -> Self { *self } @@ -2343,19 +2582,41 @@ mod root { } } - #[derive(Clone, Debug, PartialEq, ::serde::Serialize, ::serde::Deserialize)] + #[derive( + Clone, + Debug, + PartialEq, + PartialOrd, + Eq, + Ord, + Hash, + ::serde::Serialize, + ::serde::Deserialize, + )] pub struct FloatingPoint { pub precision: self::Precision, } + #[allow(clippy::derivable_impls)] + impl ::core::default::Default for FloatingPoint { + fn default() -> Self { + Self { + precision: self::Precision::Half, + } + } + } + impl FloatingPoint { #[allow(clippy::too_many_arguments)] pub fn create( builder: &mut ::planus::Builder, - precision: impl ::planus::WriteAsDefault, + field_precision: impl ::planus::WriteAsDefault< + self::Precision, + self::Precision, + >, ) -> ::planus::Offset { let prepared_precision = - precision.prepare(builder, &self::Precision::Half); + field_precision.prepare(builder, &self::Precision::Half); let mut table_writer = ::planus::table_writer::TableWriter::<4, 2>::new(builder); @@ -2517,9 +2778,26 @@ mod root { } } - #[derive(Clone, Debug, PartialEq, ::serde::Serialize, ::serde::Deserialize)] + #[derive( + Clone, + Debug, + PartialEq, + PartialOrd, + Eq, + Ord, + Hash, + ::serde::Serialize, + ::serde::Deserialize, + )] pub struct Utf8 {} + #[allow(clippy::derivable_impls)] + impl ::core::default::Default for Utf8 { + fn default() -> Self { + Self {} + } + } + impl Utf8 { #[allow(clippy::too_many_arguments)] pub fn create(builder: &mut ::planus::Builder) -> ::planus::Offset { @@ -2656,9 +2934,26 @@ mod root { } } - #[derive(Clone, Debug, PartialEq, ::serde::Serialize, ::serde::Deserialize)] + #[derive( + Clone, + Debug, + PartialEq, + PartialOrd, + Eq, + Ord, + Hash, + ::serde::Serialize, + ::serde::Deserialize, + )] pub struct Binary {} + #[allow(clippy::derivable_impls)] + impl ::core::default::Default for Binary { + fn default() -> Self { + Self {} + } + } + impl Binary { #[allow(clippy::too_many_arguments)] pub fn create(builder: &mut ::planus::Builder) -> ::planus::Offset { @@ -2795,9 +3090,26 @@ mod root { } } - #[derive(Clone, Debug, PartialEq, ::serde::Serialize, ::serde::Deserialize)] + #[derive( + Clone, + Debug, + PartialEq, + PartialOrd, + Eq, + Ord, + Hash, + ::serde::Serialize, + ::serde::Deserialize, + )] pub struct LargeUtf8 {} + #[allow(clippy::derivable_impls)] + impl ::core::default::Default for LargeUtf8 { + fn default() -> Self { + Self {} + } + } + impl LargeUtf8 { #[allow(clippy::too_many_arguments)] pub fn create(builder: &mut ::planus::Builder) -> ::planus::Offset { @@ -2934,9 +3246,26 @@ mod root { } } - #[derive(Clone, Debug, PartialEq, ::serde::Serialize, ::serde::Deserialize)] + #[derive( + Clone, + Debug, + PartialEq, + PartialOrd, + Eq, + Ord, + Hash, + ::serde::Serialize, + ::serde::Deserialize, + )] pub struct LargeBinary {} + #[allow(clippy::derivable_impls)] + impl ::core::default::Default for LargeBinary { + fn default() -> Self { + Self {} + } + } + impl LargeBinary { #[allow(clippy::too_many_arguments)] pub fn create(builder: &mut ::planus::Builder) -> ::planus::Offset { @@ -3077,18 +3406,35 @@ mod root { } } - #[derive(Clone, Debug, PartialEq, ::serde::Serialize, ::serde::Deserialize)] + #[derive( + Clone, + Debug, + PartialEq, + PartialOrd, + Eq, + Ord, + Hash, + ::serde::Serialize, + ::serde::Deserialize, + )] pub struct FixedSizeBinary { pub byte_width: i32, } + #[allow(clippy::derivable_impls)] + impl ::core::default::Default for FixedSizeBinary { + fn default() -> Self { + Self { byte_width: 0 } + } + } + impl FixedSizeBinary { #[allow(clippy::too_many_arguments)] pub fn create( builder: &mut ::planus::Builder, - byte_width: impl ::planus::WriteAsDefault, + field_byte_width: impl ::planus::WriteAsDefault, ) -> ::planus::Offset { - let prepared_byte_width = byte_width.prepare(builder, &0); + let prepared_byte_width = field_byte_width.prepare(builder, &0); let mut table_writer = ::planus::table_writer::TableWriter::<4, 4>::new(builder); @@ -3252,9 +3598,26 @@ mod root { } } - #[derive(Clone, Debug, PartialEq, ::serde::Serialize, ::serde::Deserialize)] + #[derive( + Clone, + Debug, + PartialEq, + PartialOrd, + Eq, + Ord, + Hash, + ::serde::Serialize, + ::serde::Deserialize, + )] pub struct Bool {} + #[allow(clippy::derivable_impls)] + impl ::core::default::Default for Bool { + fn default() -> Self { + Self {} + } + } + impl Bool { #[allow(clippy::too_many_arguments)] pub fn create(builder: &mut ::planus::Builder) -> ::planus::Offset { @@ -3391,26 +3754,47 @@ mod root { } } - #[derive(Clone, Debug, PartialEq, ::serde::Serialize, ::serde::Deserialize)] + #[derive( + Clone, + Debug, + PartialEq, + PartialOrd, + Eq, + Ord, + Hash, + ::serde::Serialize, + ::serde::Deserialize, + )] pub struct Decimal { pub precision: i32, pub scale: i32, pub bit_width: i32, } + #[allow(clippy::derivable_impls)] + impl ::core::default::Default for Decimal { + fn default() -> Self { + Self { + precision: 0, + scale: 0, + bit_width: 128, + } + } + } + impl Decimal { #[allow(clippy::too_many_arguments)] pub fn create( builder: &mut ::planus::Builder, - precision: impl ::planus::WriteAsDefault, - scale: impl ::planus::WriteAsDefault, - bit_width: impl ::planus::WriteAsDefault, + field_precision: impl ::planus::WriteAsDefault, + field_scale: impl ::planus::WriteAsDefault, + field_bit_width: impl ::planus::WriteAsDefault, ) -> ::planus::Offset { - let prepared_precision = precision.prepare(builder, &0); + let prepared_precision = field_precision.prepare(builder, &0); - let prepared_scale = scale.prepare(builder, &0); + let prepared_scale = field_scale.prepare(builder, &0); - let prepared_bit_width = bit_width.prepare(builder, &128); + let prepared_bit_width = field_bit_width.prepare(builder, &128); let mut table_writer = ::planus::table_writer::TableWriter::<8, 12>::new(builder); @@ -3598,7 +3982,16 @@ mod root { } #[derive( - Copy, Clone, Debug, PartialEq, Eq, ::serde::Serialize, ::serde::Deserialize, + Copy, + Clone, + Debug, + PartialEq, + Eq, + PartialOrd, + Ord, + Hash, + ::serde::Serialize, + ::serde::Deserialize, )] #[repr(i16)] pub enum DateUnit { @@ -3717,12 +4110,12 @@ mod root { } } - impl<'buf> ::planus::VectorWrite for DateUnit { + impl ::planus::VectorWrite for DateUnit { const STRIDE: usize = 2; type Value = Self; - fn prepare(&self, _builder: &mut ::planus::Builder) -> Self::Value { + fn prepare(&self, _builder: &mut ::planus::Builder) -> Self { *self } @@ -3743,18 +4136,38 @@ mod root { } } - #[derive(Clone, Debug, PartialEq, ::serde::Serialize, ::serde::Deserialize)] + #[derive( + Clone, + Debug, + PartialEq, + PartialOrd, + Eq, + Ord, + Hash, + ::serde::Serialize, + ::serde::Deserialize, + )] pub struct Date { pub unit: self::DateUnit, } + #[allow(clippy::derivable_impls)] + impl ::core::default::Default for Date { + fn default() -> Self { + Self { + unit: self::DateUnit::Millisecond, + } + } + } + impl Date { #[allow(clippy::too_many_arguments)] pub fn create( builder: &mut ::planus::Builder, - unit: impl ::planus::WriteAsDefault, + field_unit: impl ::planus::WriteAsDefault, ) -> ::planus::Offset { - let prepared_unit = unit.prepare(builder, &self::DateUnit::Millisecond); + let prepared_unit = + field_unit.prepare(builder, &self::DateUnit::Millisecond); let mut table_writer = ::planus::table_writer::TableWriter::<4, 2>::new(builder); @@ -3911,7 +4324,16 @@ mod root { } #[derive( - Copy, Clone, Debug, PartialEq, Eq, ::serde::Serialize, ::serde::Deserialize, + Copy, + Clone, + Debug, + PartialEq, + Eq, + PartialOrd, + Ord, + Hash, + ::serde::Serialize, + ::serde::Deserialize, )] #[repr(i16)] pub enum TimeUnit { @@ -4034,12 +4456,12 @@ mod root { } } - impl<'buf> ::planus::VectorWrite for TimeUnit { + impl ::planus::VectorWrite for TimeUnit { const STRIDE: usize = 2; type Value = Self; - fn prepare(&self, _builder: &mut ::planus::Builder) -> Self::Value { + fn prepare(&self, _builder: &mut ::planus::Builder) -> Self { *self } @@ -4060,22 +4482,43 @@ mod root { } } - #[derive(Clone, Debug, PartialEq, ::serde::Serialize, ::serde::Deserialize)] + #[derive( + Clone, + Debug, + PartialEq, + PartialOrd, + Eq, + Ord, + Hash, + ::serde::Serialize, + ::serde::Deserialize, + )] pub struct Time { pub unit: self::TimeUnit, pub bit_width: i32, } + #[allow(clippy::derivable_impls)] + impl ::core::default::Default for Time { + fn default() -> Self { + Self { + unit: self::TimeUnit::Millisecond, + bit_width: 32, + } + } + } + impl Time { #[allow(clippy::too_many_arguments)] pub fn create( builder: &mut ::planus::Builder, - unit: impl ::planus::WriteAsDefault, - bit_width: impl ::planus::WriteAsDefault, + field_unit: impl ::planus::WriteAsDefault, + field_bit_width: impl ::planus::WriteAsDefault, ) -> ::planus::Offset { - let prepared_unit = unit.prepare(builder, &self::TimeUnit::Millisecond); + let prepared_unit = + field_unit.prepare(builder, &self::TimeUnit::Millisecond); - let prepared_bit_width = bit_width.prepare(builder, &32); + let prepared_bit_width = field_bit_width.prepare(builder, &32); let mut table_writer = ::planus::table_writer::TableWriter::<6, 6>::new(builder); @@ -4247,24 +4690,45 @@ mod root { } } - #[derive(Clone, Debug, PartialEq, ::serde::Serialize, ::serde::Deserialize)] + #[derive( + Clone, + Debug, + PartialEq, + PartialOrd, + Eq, + Ord, + Hash, + ::serde::Serialize, + ::serde::Deserialize, + )] pub struct Timestamp { pub unit: self::TimeUnit, pub timezone: ::core::option::Option<::planus::alloc::string::String>, } + #[allow(clippy::derivable_impls)] + impl ::core::default::Default for Timestamp { + fn default() -> Self { + Self { + unit: self::TimeUnit::Second, + timezone: ::core::default::Default::default(), + } + } + } + impl Timestamp { #[allow(clippy::too_many_arguments)] pub fn create( builder: &mut ::planus::Builder, - unit: impl ::planus::WriteAsDefault, - timezone: impl ::planus::WriteAsOptional< + field_unit: impl ::planus::WriteAsDefault, + field_timezone: impl ::planus::WriteAsOptional< ::planus::Offset<::core::primitive::str>, >, ) -> ::planus::Offset { - let prepared_unit = unit.prepare(builder, &self::TimeUnit::Second); + let prepared_unit = + field_unit.prepare(builder, &self::TimeUnit::Second); - let prepared_timezone = timezone.prepare(builder); + let prepared_timezone = field_timezone.prepare(builder); let mut table_writer = ::planus::table_writer::TableWriter::<6, 6>::new(builder); @@ -4351,10 +4815,10 @@ mod root { fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { let mut f = f.debug_struct("TimestampRef"); f.field("unit", &self.unit()); - if let ::core::option::Option::Some(timezone) = + if let ::core::option::Option::Some(field_timezone) = self.timezone().transpose() { - f.field("timezone", &timezone); + f.field("timezone", &field_timezone); } f.finish() } @@ -4450,7 +4914,16 @@ mod root { } #[derive( - Copy, Clone, Debug, PartialEq, Eq, ::serde::Serialize, ::serde::Deserialize, + Copy, + Clone, + Debug, + PartialEq, + Eq, + PartialOrd, + Ord, + Hash, + ::serde::Serialize, + ::serde::Deserialize, )] #[repr(i16)] pub enum IntervalUnit { @@ -4571,12 +5044,12 @@ mod root { } } - impl<'buf> ::planus::VectorWrite for IntervalUnit { + impl ::planus::VectorWrite for IntervalUnit { const STRIDE: usize = 2; type Value = Self; - fn prepare(&self, _builder: &mut ::planus::Builder) -> Self::Value { + fn prepare(&self, _builder: &mut ::planus::Builder) -> Self { *self } @@ -4597,19 +5070,41 @@ mod root { } } - #[derive(Clone, Debug, PartialEq, ::serde::Serialize, ::serde::Deserialize)] + #[derive( + Clone, + Debug, + PartialEq, + PartialOrd, + Eq, + Ord, + Hash, + ::serde::Serialize, + ::serde::Deserialize, + )] pub struct Interval { pub unit: self::IntervalUnit, } + #[allow(clippy::derivable_impls)] + impl ::core::default::Default for Interval { + fn default() -> Self { + Self { + unit: self::IntervalUnit::YearMonth, + } + } + } + impl Interval { #[allow(clippy::too_many_arguments)] pub fn create( builder: &mut ::planus::Builder, - unit: impl ::planus::WriteAsDefault, + field_unit: impl ::planus::WriteAsDefault< + self::IntervalUnit, + self::IntervalUnit, + >, ) -> ::planus::Offset { let prepared_unit = - unit.prepare(builder, &self::IntervalUnit::YearMonth); + field_unit.prepare(builder, &self::IntervalUnit::YearMonth); let mut table_writer = ::planus::table_writer::TableWriter::<4, 2>::new(builder); @@ -4765,18 +5260,38 @@ mod root { } } - #[derive(Clone, Debug, PartialEq, ::serde::Serialize, ::serde::Deserialize)] + #[derive( + Clone, + Debug, + PartialEq, + PartialOrd, + Eq, + Ord, + Hash, + ::serde::Serialize, + ::serde::Deserialize, + )] pub struct Duration { pub unit: self::TimeUnit, } + #[allow(clippy::derivable_impls)] + impl ::core::default::Default for Duration { + fn default() -> Self { + Self { + unit: self::TimeUnit::Millisecond, + } + } + } + impl Duration { #[allow(clippy::too_many_arguments)] pub fn create( builder: &mut ::planus::Builder, - unit: impl ::planus::WriteAsDefault, + field_unit: impl ::planus::WriteAsDefault, ) -> ::planus::Offset { - let prepared_unit = unit.prepare(builder, &self::TimeUnit::Millisecond); + let prepared_unit = + field_unit.prepare(builder, &self::TimeUnit::Millisecond); let mut table_writer = ::planus::table_writer::TableWriter::<4, 2>::new(builder); @@ -4932,7 +5447,17 @@ mod root { } } - #[derive(Clone, Debug, PartialEq, ::serde::Serialize, ::serde::Deserialize)] + #[derive( + Clone, + Debug, + PartialEq, + PartialOrd, + Eq, + Ord, + Hash, + ::serde::Serialize, + ::serde::Deserialize, + )] pub enum Type { Null(::planus::alloc::boxed::Box), Int(::planus::alloc::boxed::Box), @@ -5390,26 +5915,46 @@ mod root { } } - #[derive(Clone, Debug, PartialEq, ::serde::Serialize, ::serde::Deserialize)] + #[derive( + Clone, + Debug, + PartialEq, + PartialOrd, + Eq, + Ord, + Hash, + ::serde::Serialize, + ::serde::Deserialize, + )] pub struct KeyValue { pub key: ::core::option::Option<::planus::alloc::string::String>, pub value: ::core::option::Option<::planus::alloc::string::String>, } + #[allow(clippy::derivable_impls)] + impl ::core::default::Default for KeyValue { + fn default() -> Self { + Self { + key: ::core::default::Default::default(), + value: ::core::default::Default::default(), + } + } + } + impl KeyValue { #[allow(clippy::too_many_arguments)] pub fn create( builder: &mut ::planus::Builder, - key: impl ::planus::WriteAsOptional< + field_key: impl ::planus::WriteAsOptional< ::planus::Offset<::core::primitive::str>, >, - value: impl ::planus::WriteAsOptional< + field_value: impl ::planus::WriteAsOptional< ::planus::Offset<::core::primitive::str>, >, ) -> ::planus::Offset { - let prepared_key = key.prepare(builder); + let prepared_key = field_key.prepare(builder); - let prepared_value = value.prepare(builder); + let prepared_value = field_value.prepare(builder); let mut table_writer = ::planus::table_writer::TableWriter::<6, 8>::new(builder); @@ -5493,11 +6038,14 @@ mod root { impl<'a> ::core::fmt::Debug for KeyValueRef<'a> { fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { let mut f = f.debug_struct("KeyValueRef"); - if let ::core::option::Option::Some(key) = self.key().transpose() { - f.field("key", &key); + if let ::core::option::Option::Some(field_key) = self.key().transpose() + { + f.field("key", &field_key); } - if let ::core::option::Option::Some(value) = self.value().transpose() { - f.field("value", &value); + if let ::core::option::Option::Some(field_value) = + self.value().transpose() + { + f.field("value", &field_value); } f.finish() } @@ -5597,7 +6145,16 @@ mod root { } #[derive( - Copy, Clone, Debug, PartialEq, Eq, ::serde::Serialize, ::serde::Deserialize, + Copy, + Clone, + Debug, + PartialEq, + Eq, + PartialOrd, + Ord, + Hash, + ::serde::Serialize, + ::serde::Deserialize, )] #[repr(i16)] pub enum DictionaryKind { @@ -5714,12 +6271,12 @@ mod root { } } - impl<'buf> ::planus::VectorWrite for DictionaryKind { + impl ::planus::VectorWrite for DictionaryKind { const STRIDE: usize = 2; type Value = Self; - fn prepare(&self, _builder: &mut ::planus::Builder) -> Self::Value { + fn prepare(&self, _builder: &mut ::planus::Builder) -> Self { *self } @@ -5740,7 +6297,17 @@ mod root { } } - #[derive(Clone, Debug, PartialEq, ::serde::Serialize, ::serde::Deserialize)] + #[derive( + Clone, + Debug, + PartialEq, + PartialOrd, + Eq, + Ord, + Hash, + ::serde::Serialize, + ::serde::Deserialize, + )] pub struct DictionaryEncoding { pub id: i64, pub index_type: @@ -5749,26 +6316,40 @@ mod root { pub dictionary_kind: self::DictionaryKind, } + #[allow(clippy::derivable_impls)] + impl ::core::default::Default for DictionaryEncoding { + fn default() -> Self { + Self { + id: 0, + index_type: ::core::default::Default::default(), + is_ordered: false, + dictionary_kind: self::DictionaryKind::DenseArray, + } + } + } + impl DictionaryEncoding { #[allow(clippy::too_many_arguments)] pub fn create( builder: &mut ::planus::Builder, - id: impl ::planus::WriteAsDefault, - index_type: impl ::planus::WriteAsOptional<::planus::Offset>, - is_ordered: impl ::planus::WriteAsDefault, - dictionary_kind: impl ::planus::WriteAsDefault< + field_id: impl ::planus::WriteAsDefault, + field_index_type: impl ::planus::WriteAsOptional< + ::planus::Offset, + >, + field_is_ordered: impl ::planus::WriteAsDefault, + field_dictionary_kind: impl ::planus::WriteAsDefault< self::DictionaryKind, self::DictionaryKind, >, ) -> ::planus::Offset { - let prepared_id = id.prepare(builder, &0); + let prepared_id = field_id.prepare(builder, &0); - let prepared_index_type = index_type.prepare(builder); + let prepared_index_type = field_index_type.prepare(builder); - let prepared_is_ordered = is_ordered.prepare(builder, &false); + let prepared_is_ordered = field_is_ordered.prepare(builder, &false); - let prepared_dictionary_kind = - dictionary_kind.prepare(builder, &self::DictionaryKind::DenseArray); + let prepared_dictionary_kind = field_dictionary_kind + .prepare(builder, &self::DictionaryKind::DenseArray); let mut table_writer = ::planus::table_writer::TableWriter::<10, 15>::new(builder); @@ -5891,10 +6472,10 @@ mod root { fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { let mut f = f.debug_struct("DictionaryEncodingRef"); f.field("id", &self.id()); - if let ::core::option::Option::Some(index_type) = + if let ::core::option::Option::Some(field_index_type) = self.index_type().transpose() { - f.field("index_type", &index_type); + f.field("index_type", &field_index_type); } f.field("is_ordered", &self.is_ordered()); f.field("dictionary_kind", &self.dictionary_kind()); @@ -6001,7 +6582,17 @@ mod root { } } - #[derive(Clone, Debug, PartialEq, ::serde::Serialize, ::serde::Deserialize)] + #[derive( + Clone, + Debug, + PartialEq, + PartialOrd, + Eq, + Ord, + Hash, + ::serde::Serialize, + ::serde::Deserialize, + )] pub struct Field { pub name: ::core::option::Option<::planus::alloc::string::String>, pub nullable: bool, @@ -6015,36 +6606,50 @@ mod root { ::core::option::Option<::planus::alloc::vec::Vec>, } + #[allow(clippy::derivable_impls)] + impl ::core::default::Default for Field { + fn default() -> Self { + Self { + name: ::core::default::Default::default(), + nullable: false, + type_: ::core::default::Default::default(), + dictionary: ::core::default::Default::default(), + children: ::core::default::Default::default(), + custom_metadata: ::core::default::Default::default(), + } + } + } + impl Field { #[allow(clippy::too_many_arguments)] pub fn create( builder: &mut ::planus::Builder, - name: impl ::planus::WriteAsOptional< + field_name: impl ::planus::WriteAsOptional< ::planus::Offset<::core::primitive::str>, >, - nullable: impl ::planus::WriteAsDefault, - type_: impl ::planus::WriteAsOptionalUnion, - dictionary: impl ::planus::WriteAsOptional< + field_nullable: impl ::planus::WriteAsDefault, + field_type_: impl ::planus::WriteAsOptionalUnion, + field_dictionary: impl ::planus::WriteAsOptional< ::planus::Offset, >, - children: impl ::planus::WriteAsOptional< + field_children: impl ::planus::WriteAsOptional< ::planus::Offset<[::planus::Offset]>, >, - custom_metadata: impl ::planus::WriteAsOptional< + field_custom_metadata: impl ::planus::WriteAsOptional< ::planus::Offset<[::planus::Offset]>, >, ) -> ::planus::Offset { - let prepared_name = name.prepare(builder); + let prepared_name = field_name.prepare(builder); - let prepared_nullable = nullable.prepare(builder, &false); + let prepared_nullable = field_nullable.prepare(builder, &false); - let prepared_type_ = type_.prepare(builder); + let prepared_type_ = field_type_.prepare(builder); - let prepared_dictionary = dictionary.prepare(builder); + let prepared_dictionary = field_dictionary.prepare(builder); - let prepared_children = children.prepare(builder); + let prepared_children = field_children.prepare(builder); - let prepared_custom_metadata = custom_metadata.prepare(builder); + let prepared_custom_metadata = field_custom_metadata.prepare(builder); let mut table_writer = ::planus::table_writer::TableWriter::<16, 22>::new(builder); @@ -6209,27 +6814,31 @@ mod root { impl<'a> ::core::fmt::Debug for FieldRef<'a> { fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { let mut f = f.debug_struct("FieldRef"); - if let ::core::option::Option::Some(name) = self.name().transpose() { - f.field("name", &name); + if let ::core::option::Option::Some(field_name) = + self.name().transpose() + { + f.field("name", &field_name); } f.field("nullable", &self.nullable()); - if let ::core::option::Option::Some(type_) = self.type_().transpose() { - f.field("type_", &type_); + if let ::core::option::Option::Some(field_type_) = + self.type_().transpose() + { + f.field("type_", &field_type_); } - if let ::core::option::Option::Some(dictionary) = + if let ::core::option::Option::Some(field_dictionary) = self.dictionary().transpose() { - f.field("dictionary", &dictionary); + f.field("dictionary", &field_dictionary); } - if let ::core::option::Option::Some(children) = + if let ::core::option::Option::Some(field_children) = self.children().transpose() { - f.field("children", &children); + f.field("children", &field_children); } - if let ::core::option::Option::Some(custom_metadata) = + if let ::core::option::Option::Some(field_custom_metadata) = self.custom_metadata().transpose() { - f.field("custom_metadata", &custom_metadata); + f.field("custom_metadata", &field_custom_metadata); } f.finish() } @@ -6354,7 +6963,16 @@ mod root { } #[derive( - Copy, Clone, Debug, PartialEq, Eq, ::serde::Serialize, ::serde::Deserialize, + Copy, + Clone, + Debug, + PartialEq, + Eq, + PartialOrd, + Ord, + Hash, + ::serde::Serialize, + ::serde::Deserialize, )] #[repr(i16)] pub enum Endianness { @@ -6473,12 +7091,12 @@ mod root { } } - impl<'buf> ::planus::VectorWrite for Endianness { + impl ::planus::VectorWrite for Endianness { const STRIDE: usize = 2; type Value = Self; - fn prepare(&self, _builder: &mut ::planus::Builder) -> Self::Value { + fn prepare(&self, _builder: &mut ::planus::Builder) -> Self { *self } @@ -6500,7 +7118,17 @@ mod root { } #[derive( - Copy, Clone, Debug, PartialEq, ::serde::Serialize, ::serde::Deserialize, + Copy, + Clone, + Debug, + PartialEq, + PartialOrd, + Eq, + Ord, + Hash, + Default, + ::serde::Serialize, + ::serde::Deserialize, )] pub struct Buffer { pub offset: i64, @@ -6527,6 +7155,29 @@ mod root { } } + impl ::planus::WriteAsOffset for Buffer { + fn prepare( + &self, + builder: &mut ::planus::Builder, + ) -> ::planus::Offset { + unsafe { + builder.write_with(16, 8, |buffer_position, bytes| { + let bytes = bytes.as_mut_ptr(); + + ::planus::WriteAsPrimitive::write( + self, + ::planus::Cursor::new( + &mut *(bytes + as *mut [::core::mem::MaybeUninit; 16]), + ), + buffer_position, + ); + }); + } + builder.current_offset() + } + } + impl ::planus::WriteAs for Buffer { type Prepared = Self; fn prepare(&self, _builder: &mut ::planus::Builder) -> Self { @@ -6630,7 +7281,17 @@ mod root { } } - #[derive(Clone, Debug, PartialEq, ::serde::Serialize, ::serde::Deserialize)] + #[derive( + Clone, + Debug, + PartialEq, + PartialOrd, + Eq, + Ord, + Hash, + ::serde::Serialize, + ::serde::Deserialize, + )] pub struct Schema { pub endianness: self::Endianness, pub fields: ::core::option::Option<::planus::alloc::vec::Vec>, @@ -6640,30 +7301,44 @@ mod root { ::core::option::Option<::planus::alloc::vec::Vec>, } + #[allow(clippy::derivable_impls)] + impl ::core::default::Default for Schema { + fn default() -> Self { + Self { + endianness: self::Endianness::Little, + fields: ::core::default::Default::default(), + custom_metadata: ::core::default::Default::default(), + features: ::core::default::Default::default(), + } + } + } + impl Schema { #[allow(clippy::too_many_arguments)] pub fn create( builder: &mut ::planus::Builder, - endianness: impl ::planus::WriteAsDefault< + field_endianness: impl ::planus::WriteAsDefault< self::Endianness, self::Endianness, >, - fields: impl ::planus::WriteAsOptional< + field_fields: impl ::planus::WriteAsOptional< ::planus::Offset<[::planus::Offset]>, >, - custom_metadata: impl ::planus::WriteAsOptional< + field_custom_metadata: impl ::planus::WriteAsOptional< ::planus::Offset<[::planus::Offset]>, >, - features: impl ::planus::WriteAsOptional<::planus::Offset<[self::Feature]>>, + field_features: impl ::planus::WriteAsOptional< + ::planus::Offset<[self::Feature]>, + >, ) -> ::planus::Offset { let prepared_endianness = - endianness.prepare(builder, &self::Endianness::Little); + field_endianness.prepare(builder, &self::Endianness::Little); - let prepared_fields = fields.prepare(builder); + let prepared_fields = field_fields.prepare(builder); - let prepared_custom_metadata = custom_metadata.prepare(builder); + let prepared_custom_metadata = field_custom_metadata.prepare(builder); - let prepared_features = features.prepare(builder); + let prepared_features = field_features.prepare(builder); let mut table_writer = ::planus::table_writer::TableWriter::<10, 14>::new(builder); @@ -6803,19 +7478,20 @@ mod root { fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { let mut f = f.debug_struct("SchemaRef"); f.field("endianness", &self.endianness()); - if let ::core::option::Option::Some(fields) = self.fields().transpose() + if let ::core::option::Option::Some(field_fields) = + self.fields().transpose() { - f.field("fields", &fields); + f.field("fields", &field_fields); } - if let ::core::option::Option::Some(custom_metadata) = + if let ::core::option::Option::Some(field_custom_metadata) = self.custom_metadata().transpose() { - f.field("custom_metadata", &custom_metadata); + f.field("custom_metadata", &field_custom_metadata); } - if let ::core::option::Option::Some(features) = + if let ::core::option::Option::Some(field_features) = self.features().transpose() { - f.field("features", &features); + f.field("features", &field_features); } f.finish() } @@ -6926,7 +7602,17 @@ mod root { } #[derive( - Copy, Clone, Debug, PartialEq, ::serde::Serialize, ::serde::Deserialize, + Copy, + Clone, + Debug, + PartialEq, + PartialOrd, + Eq, + Ord, + Hash, + Default, + ::serde::Serialize, + ::serde::Deserialize, )] pub struct FieldNode { pub length: i64, @@ -6953,6 +7639,29 @@ mod root { } } + impl ::planus::WriteAsOffset for FieldNode { + fn prepare( + &self, + builder: &mut ::planus::Builder, + ) -> ::planus::Offset { + unsafe { + builder.write_with(16, 8, |buffer_position, bytes| { + let bytes = bytes.as_mut_ptr(); + + ::planus::WriteAsPrimitive::write( + self, + ::planus::Cursor::new( + &mut *(bytes + as *mut [::core::mem::MaybeUninit; 16]), + ), + buffer_position, + ); + }); + } + builder.current_offset() + } + } + impl ::planus::WriteAs for FieldNode { type Prepared = Self; fn prepare(&self, _builder: &mut ::planus::Builder) -> Self { @@ -7057,7 +7766,16 @@ mod root { } #[derive( - Copy, Clone, Debug, PartialEq, Eq, ::serde::Serialize, ::serde::Deserialize, + Copy, + Clone, + Debug, + PartialEq, + Eq, + PartialOrd, + Ord, + Hash, + ::serde::Serialize, + ::serde::Deserialize, )] #[repr(i8)] pub enum CompressionType { @@ -7176,12 +7894,12 @@ mod root { } } - impl<'buf> ::planus::VectorWrite for CompressionType { + impl ::planus::VectorWrite for CompressionType { const STRIDE: usize = 1; type Value = Self; - fn prepare(&self, _builder: &mut ::planus::Builder) -> Self::Value { + fn prepare(&self, _builder: &mut ::planus::Builder) -> Self { *self } @@ -7203,7 +7921,16 @@ mod root { } #[derive( - Copy, Clone, Debug, PartialEq, Eq, ::serde::Serialize, ::serde::Deserialize, + Copy, + Clone, + Debug, + PartialEq, + Eq, + PartialOrd, + Ord, + Hash, + ::serde::Serialize, + ::serde::Deserialize, )] #[repr(i8)] pub enum BodyCompressionMethod { @@ -7325,12 +8052,12 @@ mod root { } } - impl<'buf> ::planus::VectorWrite for BodyCompressionMethod { + impl ::planus::VectorWrite for BodyCompressionMethod { const STRIDE: usize = 1; type Value = Self; - fn prepare(&self, _builder: &mut ::planus::Builder) -> Self::Value { + fn prepare(&self, _builder: &mut ::planus::Builder) -> Self { *self } @@ -7351,30 +8078,50 @@ mod root { } } - #[derive(Clone, Debug, PartialEq, ::serde::Serialize, ::serde::Deserialize)] + #[derive( + Clone, + Debug, + PartialEq, + PartialOrd, + Eq, + Ord, + Hash, + ::serde::Serialize, + ::serde::Deserialize, + )] pub struct BodyCompression { pub codec: self::CompressionType, pub method: self::BodyCompressionMethod, } + #[allow(clippy::derivable_impls)] + impl ::core::default::Default for BodyCompression { + fn default() -> Self { + Self { + codec: self::CompressionType::Lz4Frame, + method: self::BodyCompressionMethod::Buffer, + } + } + } + impl BodyCompression { #[allow(clippy::too_many_arguments)] pub fn create( builder: &mut ::planus::Builder, - codec: impl ::planus::WriteAsDefault< + field_codec: impl ::planus::WriteAsDefault< self::CompressionType, self::CompressionType, >, - method: impl ::planus::WriteAsDefault< + field_method: impl ::planus::WriteAsDefault< self::BodyCompressionMethod, self::BodyCompressionMethod, >, ) -> ::planus::Offset { let prepared_codec = - codec.prepare(builder, &self::CompressionType::Lz4Frame); + field_codec.prepare(builder, &self::CompressionType::Lz4Frame); let prepared_method = - method.prepare(builder, &self::BodyCompressionMethod::Buffer); + field_method.prepare(builder, &self::BodyCompressionMethod::Buffer); let mut table_writer = ::planus::table_writer::TableWriter::<6, 2>::new(builder); @@ -7553,7 +8300,17 @@ mod root { } } - #[derive(Clone, Debug, PartialEq, ::serde::Serialize, ::serde::Deserialize)] + #[derive( + Clone, + Debug, + PartialEq, + PartialOrd, + Eq, + Ord, + Hash, + ::serde::Serialize, + ::serde::Deserialize, + )] pub struct RecordBatch { pub length: i64, pub nodes: @@ -7565,24 +8322,40 @@ mod root { >, } + #[allow(clippy::derivable_impls)] + impl ::core::default::Default for RecordBatch { + fn default() -> Self { + Self { + length: 0, + nodes: ::core::default::Default::default(), + buffers: ::core::default::Default::default(), + compression: ::core::default::Default::default(), + } + } + } + impl RecordBatch { #[allow(clippy::too_many_arguments)] pub fn create( builder: &mut ::planus::Builder, - length: impl ::planus::WriteAsDefault, - nodes: impl ::planus::WriteAsOptional<::planus::Offset<[self::FieldNode]>>, - buffers: impl ::planus::WriteAsOptional<::planus::Offset<[self::Buffer]>>, - compression: impl ::planus::WriteAsOptional< + field_length: impl ::planus::WriteAsDefault, + field_nodes: impl ::planus::WriteAsOptional< + ::planus::Offset<[self::FieldNode]>, + >, + field_buffers: impl ::planus::WriteAsOptional< + ::planus::Offset<[self::Buffer]>, + >, + field_compression: impl ::planus::WriteAsOptional< ::planus::Offset, >, ) -> ::planus::Offset { - let prepared_length = length.prepare(builder, &0); + let prepared_length = field_length.prepare(builder, &0); - let prepared_nodes = nodes.prepare(builder); + let prepared_nodes = field_nodes.prepare(builder); - let prepared_buffers = buffers.prepare(builder); + let prepared_buffers = field_buffers.prepare(builder); - let prepared_compression = compression.prepare(builder); + let prepared_compression = field_compression.prepare(builder); let mut table_writer = ::planus::table_writer::TableWriter::<10, 20>::new(builder); @@ -7708,18 +8481,20 @@ mod root { fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { let mut f = f.debug_struct("RecordBatchRef"); f.field("length", &self.length()); - if let ::core::option::Option::Some(nodes) = self.nodes().transpose() { - f.field("nodes", &nodes); + if let ::core::option::Option::Some(field_nodes) = + self.nodes().transpose() + { + f.field("nodes", &field_nodes); } - if let ::core::option::Option::Some(buffers) = + if let ::core::option::Option::Some(field_buffers) = self.buffers().transpose() { - f.field("buffers", &buffers); + f.field("buffers", &field_buffers); } - if let ::core::option::Option::Some(compression) = + if let ::core::option::Option::Some(field_compression) = self.compression().transpose() { - f.field("compression", &compression); + f.field("compression", &field_compression); } f.finish() } @@ -7830,7 +8605,17 @@ mod root { } } - #[derive(Clone, Debug, PartialEq, ::serde::Serialize, ::serde::Deserialize)] + #[derive( + Clone, + Debug, + PartialEq, + PartialOrd, + Eq, + Ord, + Hash, + ::serde::Serialize, + ::serde::Deserialize, + )] pub struct DictionaryBatch { pub id: i64, pub data: @@ -7838,19 +8623,32 @@ mod root { pub is_delta: bool, } + #[allow(clippy::derivable_impls)] + impl ::core::default::Default for DictionaryBatch { + fn default() -> Self { + Self { + id: 0, + data: ::core::default::Default::default(), + is_delta: false, + } + } + } + impl DictionaryBatch { #[allow(clippy::too_many_arguments)] pub fn create( builder: &mut ::planus::Builder, - id: impl ::planus::WriteAsDefault, - data: impl ::planus::WriteAsOptional<::planus::Offset>, - is_delta: impl ::planus::WriteAsDefault, + field_id: impl ::planus::WriteAsDefault, + field_data: impl ::planus::WriteAsOptional< + ::planus::Offset, + >, + field_is_delta: impl ::planus::WriteAsDefault, ) -> ::planus::Offset { - let prepared_id = id.prepare(builder, &0); + let prepared_id = field_id.prepare(builder, &0); - let prepared_data = data.prepare(builder); + let prepared_data = field_data.prepare(builder); - let prepared_is_delta = is_delta.prepare(builder, &false); + let prepared_is_delta = field_is_delta.prepare(builder, &false); let mut table_writer = ::planus::table_writer::TableWriter::<8, 13>::new(builder); @@ -7950,8 +8748,10 @@ mod root { fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { let mut f = f.debug_struct("DictionaryBatchRef"); f.field("id", &self.id()); - if let ::core::option::Option::Some(data) = self.data().transpose() { - f.field("data", &data); + if let ::core::option::Option::Some(field_data) = + self.data().transpose() + { + f.field("data", &field_data); } f.field("is_delta", &self.is_delta()); f.finish() @@ -8050,7 +8850,17 @@ mod root { } } - #[derive(Clone, Debug, PartialEq, ::serde::Serialize, ::serde::Deserialize)] + #[derive( + Clone, + Debug, + PartialEq, + PartialOrd, + Eq, + Ord, + Hash, + ::serde::Serialize, + ::serde::Deserialize, + )] pub enum MessageHeader { Schema(::planus::alloc::boxed::Box), DictionaryBatch(::planus::alloc::boxed::Box), @@ -8208,7 +9018,17 @@ mod root { } } - #[derive(Clone, Debug, PartialEq, ::serde::Serialize, ::serde::Deserialize)] + #[derive( + Clone, + Debug, + PartialEq, + PartialOrd, + Eq, + Ord, + Hash, + ::serde::Serialize, + ::serde::Deserialize, + )] pub struct Message { pub version: self::MetadataVersion, pub header: ::core::option::Option, @@ -8217,28 +9037,40 @@ mod root { ::core::option::Option<::planus::alloc::vec::Vec>, } + #[allow(clippy::derivable_impls)] + impl ::core::default::Default for Message { + fn default() -> Self { + Self { + version: self::MetadataVersion::V1, + header: ::core::default::Default::default(), + body_length: 0, + custom_metadata: ::core::default::Default::default(), + } + } + } + impl Message { #[allow(clippy::too_many_arguments)] pub fn create( builder: &mut ::planus::Builder, - version: impl ::planus::WriteAsDefault< + field_version: impl ::planus::WriteAsDefault< self::MetadataVersion, self::MetadataVersion, >, - header: impl ::planus::WriteAsOptionalUnion, - body_length: impl ::planus::WriteAsDefault, - custom_metadata: impl ::planus::WriteAsOptional< + field_header: impl ::planus::WriteAsOptionalUnion, + field_body_length: impl ::planus::WriteAsDefault, + field_custom_metadata: impl ::planus::WriteAsOptional< ::planus::Offset<[::planus::Offset]>, >, ) -> ::planus::Offset { let prepared_version = - version.prepare(builder, &self::MetadataVersion::V1); + field_version.prepare(builder, &self::MetadataVersion::V1); - let prepared_header = header.prepare(builder); + let prepared_header = field_header.prepare(builder); - let prepared_body_length = body_length.prepare(builder, &0); + let prepared_body_length = field_body_length.prepare(builder, &0); - let prepared_custom_metadata = custom_metadata.prepare(builder); + let prepared_custom_metadata = field_custom_metadata.prepare(builder); let mut table_writer = ::planus::table_writer::TableWriter::<12, 19>::new(builder); @@ -8372,15 +9204,16 @@ mod root { fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { let mut f = f.debug_struct("MessageRef"); f.field("version", &self.version()); - if let ::core::option::Option::Some(header) = self.header().transpose() + if let ::core::option::Option::Some(field_header) = + self.header().transpose() { - f.field("header", &header); + f.field("header", &field_header); } f.field("body_length", &self.body_length()); - if let ::core::option::Option::Some(custom_metadata) = + if let ::core::option::Option::Some(field_custom_metadata) = self.custom_metadata().transpose() { - f.field("custom_metadata", &custom_metadata); + f.field("custom_metadata", &field_custom_metadata); } f.finish() } @@ -8486,7 +9319,17 @@ mod root { } } - #[derive(Clone, Debug, PartialEq, ::serde::Serialize, ::serde::Deserialize)] + #[derive( + Clone, + Debug, + PartialEq, + PartialOrd, + Eq, + Ord, + Hash, + ::serde::Serialize, + ::serde::Deserialize, + )] pub struct SparseTensorIndexCoo { pub indices_type: ::planus::alloc::boxed::Box, pub indices_strides: ::core::option::Option<::planus::alloc::vec::Vec>, @@ -8494,22 +9337,36 @@ mod root { pub is_canonical: bool, } + #[allow(clippy::derivable_impls)] + impl ::core::default::Default for SparseTensorIndexCoo { + fn default() -> Self { + Self { + indices_type: ::core::default::Default::default(), + indices_strides: ::core::default::Default::default(), + indices_buffer: ::core::default::Default::default(), + is_canonical: false, + } + } + } + impl SparseTensorIndexCoo { #[allow(clippy::too_many_arguments)] pub fn create( builder: &mut ::planus::Builder, - indices_type: impl ::planus::WriteAs<::planus::Offset>, - indices_strides: impl ::planus::WriteAsOptional<::planus::Offset<[i64]>>, - indices_buffer: impl ::planus::WriteAs, - is_canonical: impl ::planus::WriteAsDefault, + field_indices_type: impl ::planus::WriteAs<::planus::Offset>, + field_indices_strides: impl ::planus::WriteAsOptional< + ::planus::Offset<[i64]>, + >, + field_indices_buffer: impl ::planus::WriteAs, + field_is_canonical: impl ::planus::WriteAsDefault, ) -> ::planus::Offset { - let prepared_indices_type = indices_type.prepare(builder); + let prepared_indices_type = field_indices_type.prepare(builder); - let prepared_indices_strides = indices_strides.prepare(builder); + let prepared_indices_strides = field_indices_strides.prepare(builder); - let prepared_indices_buffer = indices_buffer.prepare(builder); + let prepared_indices_buffer = field_indices_buffer.prepare(builder); - let prepared_is_canonical = is_canonical.prepare(builder, &false); + let prepared_is_canonical = field_is_canonical.prepare(builder, &false); let mut table_writer = ::planus::table_writer::TableWriter::<10, 25>::new(builder); @@ -8618,10 +9475,10 @@ mod root { fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { let mut f = f.debug_struct("SparseTensorIndexCooRef"); f.field("indices_type", &self.indices_type()); - if let ::core::option::Option::Some(indices_strides) = + if let ::core::option::Option::Some(field_indices_strides) = self.indices_strides().transpose() { - f.field("indices_strides", &indices_strides); + f.field("indices_strides", &field_indices_strides); } f.field("indices_buffer", &self.indices_buffer()); f.field("is_canonical", &self.is_canonical()); @@ -8730,7 +9587,16 @@ mod root { } #[derive( - Copy, Clone, Debug, PartialEq, Eq, ::serde::Serialize, ::serde::Deserialize, + Copy, + Clone, + Debug, + PartialEq, + Eq, + PartialOrd, + Ord, + Hash, + ::serde::Serialize, + ::serde::Deserialize, )] #[repr(i16)] pub enum SparseMatrixCompressedAxis { @@ -8859,12 +9725,12 @@ mod root { } } - impl<'buf> ::planus::VectorWrite for SparseMatrixCompressedAxis { + impl ::planus::VectorWrite for SparseMatrixCompressedAxis { const STRIDE: usize = 2; type Value = Self; - fn prepare(&self, _builder: &mut ::planus::Builder) -> Self::Value { + fn prepare(&self, _builder: &mut ::planus::Builder) -> Self { *self } @@ -8885,7 +9751,17 @@ mod root { } } - #[derive(Clone, Debug, PartialEq, ::serde::Serialize, ::serde::Deserialize)] + #[derive( + Clone, + Debug, + PartialEq, + PartialOrd, + Eq, + Ord, + Hash, + ::serde::Serialize, + ::serde::Deserialize, + )] pub struct SparseMatrixIndexCsx { pub compressed_axis: self::SparseMatrixCompressedAxis, pub indptr_type: ::planus::alloc::boxed::Box, @@ -8894,29 +9770,42 @@ mod root { pub indices_buffer: self::Buffer, } + #[allow(clippy::derivable_impls)] + impl ::core::default::Default for SparseMatrixIndexCsx { + fn default() -> Self { + Self { + compressed_axis: self::SparseMatrixCompressedAxis::Row, + indptr_type: ::core::default::Default::default(), + indptr_buffer: ::core::default::Default::default(), + indices_type: ::core::default::Default::default(), + indices_buffer: ::core::default::Default::default(), + } + } + } + impl SparseMatrixIndexCsx { #[allow(clippy::too_many_arguments)] pub fn create( builder: &mut ::planus::Builder, - compressed_axis: impl ::planus::WriteAsDefault< + field_compressed_axis: impl ::planus::WriteAsDefault< self::SparseMatrixCompressedAxis, self::SparseMatrixCompressedAxis, >, - indptr_type: impl ::planus::WriteAs<::planus::Offset>, - indptr_buffer: impl ::planus::WriteAs, - indices_type: impl ::planus::WriteAs<::planus::Offset>, - indices_buffer: impl ::planus::WriteAs, + field_indptr_type: impl ::planus::WriteAs<::planus::Offset>, + field_indptr_buffer: impl ::planus::WriteAs, + field_indices_type: impl ::planus::WriteAs<::planus::Offset>, + field_indices_buffer: impl ::planus::WriteAs, ) -> ::planus::Offset { - let prepared_compressed_axis = compressed_axis + let prepared_compressed_axis = field_compressed_axis .prepare(builder, &self::SparseMatrixCompressedAxis::Row); - let prepared_indptr_type = indptr_type.prepare(builder); + let prepared_indptr_type = field_indptr_type.prepare(builder); - let prepared_indptr_buffer = indptr_buffer.prepare(builder); + let prepared_indptr_buffer = field_indptr_buffer.prepare(builder); - let prepared_indices_type = indices_type.prepare(builder); + let prepared_indices_type = field_indices_type.prepare(builder); - let prepared_indices_buffer = indices_buffer.prepare(builder); + let prepared_indices_buffer = field_indices_buffer.prepare(builder); let mut table_writer = ::planus::table_writer::TableWriter::<12, 42>::new(builder); @@ -9134,7 +10023,17 @@ mod root { } } - #[derive(Clone, Debug, PartialEq, ::serde::Serialize, ::serde::Deserialize)] + #[derive( + Clone, + Debug, + PartialEq, + PartialOrd, + Eq, + Ord, + Hash, + ::serde::Serialize, + ::serde::Deserialize, + )] pub struct SparseTensorIndexCsf { pub indptr_type: ::planus::alloc::boxed::Box, pub indptr_buffers: ::planus::alloc::vec::Vec, @@ -9147,21 +10046,25 @@ mod root { #[allow(clippy::too_many_arguments)] pub fn create( builder: &mut ::planus::Builder, - indptr_type: impl ::planus::WriteAs<::planus::Offset>, - indptr_buffers: impl ::planus::WriteAs<::planus::Offset<[self::Buffer]>>, - indices_type: impl ::planus::WriteAs<::planus::Offset>, - indices_buffers: impl ::planus::WriteAs<::planus::Offset<[self::Buffer]>>, - axis_order: impl ::planus::WriteAs<::planus::Offset<[i32]>>, + field_indptr_type: impl ::planus::WriteAs<::planus::Offset>, + field_indptr_buffers: impl ::planus::WriteAs< + ::planus::Offset<[self::Buffer]>, + >, + field_indices_type: impl ::planus::WriteAs<::planus::Offset>, + field_indices_buffers: impl ::planus::WriteAs< + ::planus::Offset<[self::Buffer]>, + >, + field_axis_order: impl ::planus::WriteAs<::planus::Offset<[i32]>>, ) -> ::planus::Offset { - let prepared_indptr_type = indptr_type.prepare(builder); + let prepared_indptr_type = field_indptr_type.prepare(builder); - let prepared_indptr_buffers = indptr_buffers.prepare(builder); + let prepared_indptr_buffers = field_indptr_buffers.prepare(builder); - let prepared_indices_type = indices_type.prepare(builder); + let prepared_indices_type = field_indices_type.prepare(builder); - let prepared_indices_buffers = indices_buffers.prepare(builder); + let prepared_indices_buffers = field_indices_buffers.prepare(builder); - let prepared_axis_order = axis_order.prepare(builder); + let prepared_axis_order = field_axis_order.prepare(builder); let mut table_writer = ::planus::table_writer::TableWriter::<12, 20>::new(builder); @@ -9367,7 +10270,17 @@ mod root { } } - #[derive(Clone, Debug, PartialEq, ::serde::Serialize, ::serde::Deserialize)] + #[derive( + Clone, + Debug, + PartialEq, + PartialOrd, + Eq, + Ord, + Hash, + ::serde::Serialize, + ::serde::Deserialize, + )] pub enum SparseTensorIndex { SparseTensorIndexCoo( ::planus::alloc::boxed::Box, @@ -9497,7 +10410,17 @@ mod root { } } - #[derive(Clone, Debug, PartialEq, ::serde::Serialize, ::serde::Deserialize)] + #[derive( + Clone, + Debug, + PartialEq, + PartialOrd, + Eq, + Ord, + Hash, + ::serde::Serialize, + ::serde::Deserialize, + )] pub struct SparseTensor { pub type_: self::Type, pub shape: ::planus::alloc::vec::Vec, @@ -9510,23 +10433,24 @@ mod root { #[allow(clippy::too_many_arguments)] pub fn create( builder: &mut ::planus::Builder, - type_: impl ::planus::WriteAsUnion, - shape: impl ::planus::WriteAs< + field_type_: impl ::planus::WriteAsUnion, + field_shape: impl ::planus::WriteAs< ::planus::Offset<[::planus::Offset]>, >, - non_zero_length: impl ::planus::WriteAsDefault, - sparse_index: impl ::planus::WriteAsUnion, - data: impl ::planus::WriteAs, + field_non_zero_length: impl ::planus::WriteAsDefault, + field_sparse_index: impl ::planus::WriteAsUnion, + field_data: impl ::planus::WriteAs, ) -> ::planus::Offset { - let prepared_type_ = type_.prepare(builder); + let prepared_type_ = field_type_.prepare(builder); - let prepared_shape = shape.prepare(builder); + let prepared_shape = field_shape.prepare(builder); - let prepared_non_zero_length = non_zero_length.prepare(builder, &0); + let prepared_non_zero_length = + field_non_zero_length.prepare(builder, &0); - let prepared_sparse_index = sparse_index.prepare(builder); + let prepared_sparse_index = field_sparse_index.prepare(builder); - let prepared_data = data.prepare(builder); + let prepared_data = field_data.prepare(builder); let mut table_writer = ::planus::table_writer::TableWriter::<16, 38>::new(builder); @@ -9744,24 +10668,44 @@ mod root { } } - #[derive(Clone, Debug, PartialEq, ::serde::Serialize, ::serde::Deserialize)] + #[derive( + Clone, + Debug, + PartialEq, + PartialOrd, + Eq, + Ord, + Hash, + ::serde::Serialize, + ::serde::Deserialize, + )] pub struct TensorDim { pub size: i64, pub name: ::core::option::Option<::planus::alloc::string::String>, } + #[allow(clippy::derivable_impls)] + impl ::core::default::Default for TensorDim { + fn default() -> Self { + Self { + size: 0, + name: ::core::default::Default::default(), + } + } + } + impl TensorDim { #[allow(clippy::too_many_arguments)] pub fn create( builder: &mut ::planus::Builder, - size: impl ::planus::WriteAsDefault, - name: impl ::planus::WriteAsOptional< + field_size: impl ::planus::WriteAsDefault, + field_name: impl ::planus::WriteAsOptional< ::planus::Offset<::core::primitive::str>, >, ) -> ::planus::Offset { - let prepared_size = size.prepare(builder, &0); + let prepared_size = field_size.prepare(builder, &0); - let prepared_name = name.prepare(builder); + let prepared_name = field_name.prepare(builder); let mut table_writer = ::planus::table_writer::TableWriter::<6, 12>::new(builder); @@ -9844,8 +10788,10 @@ mod root { fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { let mut f = f.debug_struct("TensorDimRef"); f.field("size", &self.size()); - if let ::core::option::Option::Some(name) = self.name().transpose() { - f.field("name", &name); + if let ::core::option::Option::Some(field_name) = + self.name().transpose() + { + f.field("name", &field_name); } f.finish() } @@ -9938,7 +10884,17 @@ mod root { } } - #[derive(Clone, Debug, PartialEq, ::serde::Serialize, ::serde::Deserialize)] + #[derive( + Clone, + Debug, + PartialEq, + PartialOrd, + Eq, + Ord, + Hash, + ::serde::Serialize, + ::serde::Deserialize, + )] pub struct Tensor { pub type_: self::Type, pub shape: ::planus::alloc::vec::Vec, @@ -9950,20 +10906,20 @@ mod root { #[allow(clippy::too_many_arguments)] pub fn create( builder: &mut ::planus::Builder, - type_: impl ::planus::WriteAsUnion, - shape: impl ::planus::WriteAs< + field_type_: impl ::planus::WriteAsUnion, + field_shape: impl ::planus::WriteAs< ::planus::Offset<[::planus::Offset]>, >, - strides: impl ::planus::WriteAsOptional<::planus::Offset<[i64]>>, - data: impl ::planus::WriteAs, + field_strides: impl ::planus::WriteAsOptional<::planus::Offset<[i64]>>, + field_data: impl ::planus::WriteAs, ) -> ::planus::Offset { - let prepared_type_ = type_.prepare(builder); + let prepared_type_ = field_type_.prepare(builder); - let prepared_shape = shape.prepare(builder); + let prepared_shape = field_shape.prepare(builder); - let prepared_strides = strides.prepare(builder); + let prepared_strides = field_strides.prepare(builder); - let prepared_data = data.prepare(builder); + let prepared_data = field_data.prepare(builder); let mut table_writer = ::planus::table_writer::TableWriter::<12, 29>::new(builder); @@ -10067,10 +11023,10 @@ mod root { let mut f = f.debug_struct("TensorRef"); f.field("type_", &self.type_()); f.field("shape", &self.shape()); - if let ::core::option::Option::Some(strides) = + if let ::core::option::Option::Some(field_strides) = self.strides().transpose() { - f.field("strides", &strides); + f.field("strides", &field_strides); } f.field("data", &self.data()); f.finish()