fn parse_options()

in core/sdk/src/client.rs [560:629]
69 lines of code
3 McCabe index (conditional complexity)

    fn parse_options(options: &str) -> Result<ConnectionStringOptions, IggyError> {
        let options = options.split('&').collect::<Vec<&str>>();
        let mut tls_enabled = false;
        let mut tls_domain = "localhost".to_string();
        let mut tls_ca_file = None;
        let mut reconnection_retries = "unlimited".to_owned();
        let mut reconnection_interval = "1s".to_owned();
        let mut reestablish_after = "5s".to_owned();
        let mut heartbeat_interval = "5s".to_owned();
        let mut nodelay = false;

        for option in options {
            let option_parts = option.split('=').collect::<Vec<&str>>();
            if option_parts.len() != 2 {
                return Err(IggyError::InvalidConnectionString);
            }
            match option_parts[0] {
                "tls" => {
                    tls_enabled = option_parts[1] == "true";
                }
                "tls_domain" => {
                    tls_domain = option_parts[1].to_string();
                }
                "tls_ca_file" => {
                    tls_ca_file = Some(option_parts[1].to_string());
                }
                "reconnection_retries" => {
                    reconnection_retries = option_parts[1].to_string();
                }
                "reconnection_interval" => {
                    reconnection_interval = option_parts[1].to_string();
                }
                "reestablish_after" => {
                    reestablish_after = option_parts[1].to_string();
                }
                "heartbeat_interval" => {
                    heartbeat_interval = option_parts[1].to_string();
                }
                "nodelay" => {
                    nodelay = option_parts[1] == "true";
                }
                _ => {
                    return Err(IggyError::InvalidConnectionString);
                }
            }
        }
        Ok(ConnectionStringOptions {
            tls_enabled,
            tls_domain,
            tls_ca_file,
            heartbeat_interval: IggyDuration::from_str(heartbeat_interval.as_str())
                .map_err(|_| IggyError::InvalidConnectionString)?,
            reconnection: TcpClientReconnectionConfig {
                enabled: true,
                max_retries: match reconnection_retries.as_str() {
                    "unlimited" => None,
                    _ => Some(
                        reconnection_retries
                            .parse()
                            .map_err(|_| IggyError::InvalidNumberValue)?,
                    ),
                },
                interval: IggyDuration::from_str(reconnection_interval.as_str())
                    .map_err(|_| IggyError::InvalidConnectionString)?,
                reestablish_after: IggyDuration::from_str(reestablish_after.as_str())
                    .map_err(|_| IggyError::InvalidConnectionString)?,
            },
            nodelay,
        })
    }