move fill value repeat into ArrayBytesFixedDisjointView::fill

Author: LDeakin

zarrs/src/array/array_bytes_fixed_disjoint_view.rs

@@ -194,33 +194,31 @@ impl<'a> ArrayBytesFixedDisjointView<'a> {
         self.contiguous_indices().contiguous_elements_usize() * self.data_type_size
     }
 
-    /// Fill the view with a constant per contiguous slice.
-    ///
-    /// The constant value must be the same length as the byte length of contiguous elements in the view.
+    /// Fill the view with the fill value.
     ///
     /// # Errors
-    /// Returns [`InvalidBytesLengthError`] if the length of `fill_value_contiguous` does not match [`Self::contiguous_bytes_len`].
+    /// Returns [`InvalidBytesLengthError`] if the length of the `fill_value` does not match the data type size.
     ///
     /// # Panics
     /// Panics if an offset into the internal bytes reference exceeds [`usize::MAX`].
-    pub fn copy_from_slice_to_contiguous_elements(
-        &mut self,
-        fill_value_contiguous: &[u8],
-    ) -> Result<(), InvalidBytesLengthError> {
-        let contiguous_indices = self.contiguous_linearised_indices();
-        let length = self.contiguous_bytes_len();
-        if fill_value_contiguous.len() != length {
+    pub fn fill(&mut self, fill_value: &[u8]) -> Result<(), InvalidBytesLengthError> {
+        if fill_value.len() != self.data_type_size {
             return Err(InvalidBytesLengthError::new(
-                fill_value_contiguous.len(),
-                length,
+                fill_value.len(),
+                self.data_type_size,
             ));
         }
+
+        let fill_value_contiguous = fill_value.repeat(self.num_contiguous_elements());
+        let length = self.contiguous_bytes_len();
+        debug_assert_eq!(fill_value_contiguous.len(), length);
+        let contiguous_indices = self.contiguous_linearised_indices();
         contiguous_indices.into_iter().for_each(|index| {
             let offset = usize::try_from(index * self.data_type_size as u64).unwrap();
             unsafe {
                 self.bytes
                     .index_mut(offset..offset + length)
-                    .copy_from_slice(fill_value_contiguous);
+                    .copy_from_slice(&fill_value_contiguous);
             }
         });
         Ok(())

zarrs/src/array/codec/array_to_bytes/sharding/sharding_codec.rs

@@ -273,12 +273,8 @@ impl ArrayToBytesCodecTraits for ShardingCodec {
                         let offset = shard_index[chunk_index * 2];
                         let size = shard_index[chunk_index * 2 + 1];
                         if offset == u64::MAX && size == u64::MAX {
-                            let fill_value_contiguous = shard_representation
-                                .fill_value()
-                                .as_ne_bytes()
-                                .repeat(output_view_inner_chunk.num_contiguous_elements());
                             output_view_inner_chunk
-                                .copy_from_slice_to_contiguous_elements(&fill_value_contiguous)?;
+                                .fill(shard_representation.fill_value().as_ne_bytes())?;
                         } else if usize::try_from(offset + size).unwrap() > encoded_shard.len() {
                             return Err(CodecError::Other(
                                 "The shard index references out-of-bounds bytes. The chunk may be corrupted."
@@ -371,12 +367,7 @@ impl ArrayToBytesCodecTraits for ShardingCodec {
             let offset = shard_index[chunk_index * 2];
             let size = shard_index[chunk_index * 2 + 1];
             if offset == u64::MAX && size == u64::MAX {
-                let fill_value_contiguous = shard_representation
-                    .fill_value()
-                    .as_ne_bytes()
-                    .repeat(output_view_inner_chunk.num_contiguous_elements());
-                output_view_inner_chunk
-                    .copy_from_slice_to_contiguous_elements(&fill_value_contiguous)?;
+                output_view_inner_chunk.fill(shard_representation.fill_value().as_ne_bytes())?;
             } else if usize::try_from(offset + size).unwrap() > encoded_shard.len() {
                 return Err(CodecError::Other(
                     "The shard index references out-of-bounds bytes. The chunk may be corrupted."

zarrs/src/array/codec/array_to_bytes/sharding/sharding_partial_decoder.rs

@@ -651,13 +651,8 @@ impl AsyncArrayPartialDecoderTraits for AsyncShardingPartialDecoder {
                                             .unwrap(),
                                     )
                                 };
-                                let fill_value_contiguous = self
-                                    .decoded_representation
-                                    .fill_value()
-                                    .as_ne_bytes()
-                                    .repeat(output_view.num_contiguous_elements());
                                 output_view
-                                    .copy_from_slice_to_contiguous_elements(&fill_value_contiguous)
+                                    .fill(self.decoded_representation.fill_value().as_ne_bytes())
                                     .map_err(CodecError::from)
                             }
                         )?;