Function read_codec

avro/src/reader/block.rs:298–355

(metadata: &HashMap<String, Value>)

        }
        Ok(())
    }
}

fn read_codec(metadata: &mut HashMap<String, Value>) -> AvroResult<Codec> {
    let result = metadata
        .remove("avro.codec")
        .map(|codec| {
            if let Value::Bytes(bytes) = codec {
                match String::from_utf8(bytes) {
                    Ok(utf8) => Ok(utf8),
                    Err(utf8_error) => Err(Details::ConvertToUtf8(utf8_error).into()),
                }
            } else {
                unreachable!("Metadata would fail to decode if it is not Value::Bytes")
            }
        })
        .map(|codec_res| match codec_res {
            Ok(codec) => match Codec::from_str(&codec) {
                Ok(codec) => match codec {
                    #[cfg(feature = "bzip")]
                    Codec::Bzip2(_) => {
                        use crate::Bzip2Settings;
                        if let Some(Value::Bytes(bytes)) =
                            metadata.remove("avro.codec.compression_level")
                        {
                            match bytes.first() {
                                Some(&level) => Ok(Codec::Bzip2(Bzip2Settings::new(level))),
                                None => Err(Details::BadCodecMetadata.into()),
                            }
                        } else {
                            Ok(codec)
                        }
                    }
                    #[cfg(feature = "xz")]
                    Codec::Xz(_) => {
                        use crate::XzSettings;
                        if let Some(Value::Bytes(bytes)) =
                            metadata.remove("avro.codec.compression_level")
                        {
                            match bytes.first() {
                                Some(&level) => Ok(Codec::Xz(XzSettings::new(level))),
                                None => Err(Details::BadCodecMetadata.into()),
                            }
                        } else {
                            Ok(codec)
                        }
                    }
                    #[cfg(feature = "zstandard")]
                    Codec::Zstandard(_) => {
                        use crate::ZstandardSettings;
                        if let Some(Value::Bytes(bytes)) =
                            metadata.remove("avro.codec.compression_level")
                        {
                            match bytes.first() {
                                Some(&level) => Ok(Codec::Zstandard(ZstandardSettings::new(level))),
                                None => Err(Details::BadCodecMetadata.into()),
                            }
                        } else {