fn serialize_str_with_schema()

in avro/src/ser_schema.rs [901:955]

• 53 lines of code
• 3 McCabe index (conditional complexity)

    fn serialize_str_with_schema(&mut self, value: &str, schema: &Schema) -> Result<usize, Error> {
        let create_error = |cause: String| Error::SerializeValueWithSchema {
            value_type: "string",
            value: format!("{value}. Cause: {cause}"),
            schema: schema.clone(),
        };

        match schema {
            Schema::String | Schema::Bytes | Schema::Uuid => self.write_bytes(value.as_bytes()),
            Schema::BigDecimal => {
                // If we get a string for a `BigDecimal` type, expect a display string representation, such as "12.75"
                let decimal_val =
                    BigDecimal::from_str(value).map_err(|e| create_error(e.to_string()))?;
                let decimal_bytes = big_decimal_as_bytes(&decimal_val)?;
                self.write_bytes(decimal_bytes.as_slice())
            }
            Schema::Fixed(fixed_schema) => {
                if value.len() == fixed_schema.size {
                    self.writer
                        .write(value.as_bytes())
                        .map_err(Error::WriteBytes)
                } else {
                    Err(create_error(format!(
                        "Fixed schema size ({}) does not match the value length ({})",
                        fixed_schema.size,
                        value.len()
                    )))
                }
            }
            Schema::Ref { name } => {
                let ref_schema = self.get_ref_schema(name)?;
                self.serialize_str_with_schema(value, ref_schema)
            }
            Schema::Union(union_schema) => {
                for (i, variant_schema) in union_schema.schemas.iter().enumerate() {
                    match variant_schema {
                        Schema::String
                        | Schema::Bytes
                        | Schema::Uuid
                        | Schema::Fixed(_)
                        | Schema::Ref { name: _ } => {
                            encode_int(i as i32, &mut *self.writer)?;
                            return self.serialize_str_with_schema(value, variant_schema);
                        }
                        _ => { /* skip */ }
                    }
                }
                Err(create_error(format!(
                    "Expected one of the union variants {:?}. Got: String",
                    union_schema.schemas
                )))
            }
            expected => Err(create_error(format!("Expected: {expected}. Got: String"))),
        }
    }