fn serialize()

in src/serialize/per_type/numpy.rs [312:404]
93 lines of code
6 McCabe index (conditional complexity)

    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
    where
        S: Serializer,
    {
        if self.is_zero_dimensional {
            // For zero-dimensional arrays, serialize the single value directly
            match self.kind {
                ItemType::F64 => DataTypeF64 { obj: unsafe { *(self.data() as *const f64) } }.serialize(serializer),
                ItemType::F32 => DataTypeF32 { obj: unsafe { *(self.data() as *const f32) } }.serialize(serializer),
                ItemType::F16 => DataTypeF16 { obj: unsafe { *(self.data() as *const u16) } }.serialize(serializer),
                ItemType::U64 => DataTypeU64 { obj: unsafe { *(self.data() as *const u64) } }.serialize(serializer),
                ItemType::U32 => DataTypeU32 { obj: unsafe { *(self.data() as *const u32) } }.serialize(serializer),
                ItemType::U16 => DataTypeU16 { obj: unsafe { *(self.data() as *const u16) } }.serialize(serializer),
                ItemType::U8 => DataTypeU8 { obj: unsafe { *(self.data() as *const u8) } }.serialize(serializer),
                ItemType::I64 => DataTypeI64 { obj: unsafe { *(self.data() as *const i64) } }.serialize(serializer),
                ItemType::I32 => DataTypeI32 { obj: unsafe { *(self.data() as *const i32) } }.serialize(serializer),
                ItemType::I16 => DataTypeI16 { obj: unsafe { *(self.data() as *const i16) } }.serialize(serializer),
                ItemType::I8 => DataTypeI8 { obj: unsafe { *(self.data() as *const i8) } }.serialize(serializer),
                ItemType::BOOL => DataTypeBool { obj: unsafe { *(self.data() as *const u8) } }.serialize(serializer),
                ItemType::DATETIME64(unit) => {
                    let val = unsafe { *(self.data() as *const i64) };
                    unit.datetime(val, self.opts)
                        .map_err(NumpyDateTimeError::into_serde_err)?
                        .serialize(serializer)
                },
            }
        } else if unlikely!(!(self.depth >= self.dimensions() || self.shape()[self.depth] != 0)) {
            ZeroListSerializer::new().serialize(serializer)
        } else if !self.children.is_empty() {
            let mut seq = serializer.serialize_seq(None).unwrap();
            for child in &self.children {
                seq.serialize_element(child).unwrap();
            }
            seq.end()
        } else {
            match self.kind {
                ItemType::F64 => {
                    NumpyF64Array::new(slice!(self.data() as *const f64, self.num_items()))
                        .serialize(serializer)
                }
                ItemType::F32 => {
                    NumpyF32Array::new(slice!(self.data() as *const f32, self.num_items()))
                        .serialize(serializer)
                }
                ItemType::F16 => {
                    NumpyF16Array::new(slice!(self.data() as *const u16, self.num_items()))
                        .serialize(serializer)
                }
                ItemType::U64 => {
                    NumpyU64Array::new(slice!(self.data() as *const u64, self.num_items()))
                        .serialize(serializer)
                }
                ItemType::U32 => {
                    NumpyU32Array::new(slice!(self.data() as *const u32, self.num_items()))
                        .serialize(serializer)
                }
                ItemType::U16 => {
                    NumpyU16Array::new(slice!(self.data() as *const u16, self.num_items()))
                        .serialize(serializer)
                }
                ItemType::U8 => {
                    NumpyU8Array::new(slice!(self.data() as *const u8, self.num_items()))
                        .serialize(serializer)
                }
                ItemType::I64 => {
                    NumpyI64Array::new(slice!(self.data() as *const i64, self.num_items()))
                        .serialize(serializer)
                }
                ItemType::I32 => {
                    NumpyI32Array::new(slice!(self.data() as *const i32, self.num_items()))
                        .serialize(serializer)
                }
                ItemType::I16 => {
                    NumpyI16Array::new(slice!(self.data() as *const i16, self.num_items()))
                        .serialize(serializer)
                }
                ItemType::I8 => {
                    NumpyI8Array::new(slice!(self.data() as *const i8, self.num_items()))
                        .serialize(serializer)
                }
                ItemType::BOOL => {
                    NumpyBoolArray::new(slice!(self.data() as *const u8, self.num_items()))
                        .serialize(serializer)
                }
                ItemType::DATETIME64(unit) => NumpyDatetime64Array::new(
                    slice!(self.data() as *const i64, self.num_items()),
                    unit,
                    self.opts,
                )
                .serialize(serializer),
            }
        }
    }