fn serialize_field()

in avro/src/ser_schema.rs [324:385]

• 56 lines of code
• 8 McCabe index (conditional complexity)

    fn serialize_field<T>(&mut self, key: &'static str, value: &T) -> Result<(), Self::Error>
    where
        T: ?Sized + ser::Serialize,
    {
        if self.item_count >= self.record_schema.fields.len() {
            return Err(Error::FieldName(String::from(key)));
        }

        let next_field = &self.record_schema.fields[self.item_count];
        let next_field_matches = match &next_field.aliases {
            Some(aliases) => {
                key == next_field.name.as_str() || aliases.iter().any(|a| key == a.as_str())
            }
            None => key == next_field.name.as_str(),
        };

        if next_field_matches {
            self.serialize_next_field(&value).map_err(|e| {
                Error::SerializeRecordFieldWithSchema {
                    field_name: key,
                    record_schema: Schema::Record(self.record_schema.clone()),
                    error: Box::new(e),
                }
            })?;
            Ok(())
        } else {
            if self.item_count < self.record_schema.fields.len() {
                for i in self.item_count..self.record_schema.fields.len() {
                    let field = &self.record_schema.fields[i];
                    let field_matches = match &field.aliases {
                        Some(aliases) => {
                            key == field.name.as_str() || aliases.iter().any(|a| key == a.as_str())
                        }
                        None => key == field.name.as_str(),
                    };

                    if field_matches {
                        let mut buffer: Vec<u8> = Vec::with_capacity(RECORD_FIELD_INIT_BUFFER_SIZE);
                        let mut value_ser = SchemaAwareWriteSerializer::new(
                            &mut buffer,
                            &field.schema,
                            self.ser.names,
                            self.ser.enclosing_namespace.clone(),
                        );
                        value.serialize(&mut value_ser).map_err(|e| {
                            Error::SerializeRecordFieldWithSchema {
                                field_name: key,
                                record_schema: Schema::Record(self.record_schema.clone()),
                                error: Box::new(e),
                            }
                        })?;

                        self.buffered_fields[i] = Some(buffer);

                        return Ok(());
                    }
                }
            }

            Err(Error::FieldName(String::from(key)))
        }
    }