odds_converter 0.1.0

A fast, accurate Rust library for converting between American, Decimal, and Fractional betting odds formats
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102

//! Display and parsing functionality for odds.
//!
//! This module implements string formatting and parsing for odds, allowing easy
//! conversion between odds and their string representations.

use crate::{Odds, OddsError, OddsFormat};
use std::fmt;
use std::str::FromStr;

impl fmt::Display for Odds {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match &self.format {
            OddsFormat::American(value) => {
                if *value > 0 {
                    write!(f, "+{}", value)
                } else {
                    write!(f, "{}", value)
                }
            }
            OddsFormat::Decimal(value) => write!(f, "{:.2}", value),
            OddsFormat::Fractional(num, den) => write!(f, "{}/{}", num, den),
        }
    }
}

impl FromStr for Odds {
    type Err = OddsError;

    fn from_str(s: &str) -> Result<Self, Self::Err> {
        let s = s.trim();

        if s.is_empty() {
            return Err(OddsError::ParseError("Empty string".to_string()));
        }

        // Try American format first (starts with + or - or is just a number)
        if s.starts_with('+') || s.starts_with('-') || s.chars().all(|c| c.is_ascii_digit()) {
            if let Ok(value) = s.parse::<i32>() {
                let odds = Odds::new_american(value);
                odds.validate()?;
                return Ok(odds);
            } else if s.starts_with('+') || s.starts_with('-') {
                return Err(OddsError::ParseError(format!(
                    "Invalid American odds format: '{}'",
                    s
                )));
            }
        }

        // Try fractional format (contains /)
        if s.contains('/') {
            let parts: Vec<&str> = s.split('/').collect();
            if parts.len() != 2 {
                return Err(OddsError::ParseError(format!(
                    "Invalid fractional format, expected 'num/den': '{}'",
                    s
                )));
            }

            let num_str = parts[0].trim();
            let den_str = parts[1].trim();

            if num_str.is_empty() || den_str.is_empty() {
                return Err(OddsError::ParseError(
                    "Empty numerator or denominator in fraction".to_string(),
                ));
            }

            match (num_str.parse::<u32>(), den_str.parse::<u32>()) {
                (Ok(num), Ok(den)) => {
                    let odds = Odds::new_fractional(num, den);
                    odds.validate()?;
                    return Ok(odds);
                }
                (Err(_), _) => {
                    return Err(OddsError::ParseError(format!(
                        "Invalid numerator: '{}'",
                        num_str
                    )))
                }
                (_, Err(_)) => {
                    return Err(OddsError::ParseError(format!(
                        "Invalid denominator: '{}'",
                        den_str
                    )))
                }
            }
        }

        // Try decimal format
        if let Ok(value) = s.parse::<f64>() {
            let odds = Odds::new_decimal(value);
            odds.validate()?;
            return Ok(odds);
        }

        Err(OddsError::ParseError(format!(
            "Unable to parse '{}' as any odds format",
            s
        )))
    }
}