lib_efo/stats/implementations/

from_impl.rs

//! All from implementations

use crate::stats::FactionId;
use crate::{
    error::EpochError,
    stats::{self, GenericStat, ListStats, Position, PositionGrid, PositionIdentifier, StatPair},
};
use std::str::FromStr;

impl FromStr for StatPair {
    type Err = EpochError;

    /// Parse a string into a `StatPair`.
    ///
    /// The input can be either in the form `"stat:value"` or `"stat value"`.
    /// If the format is invalid, an `EpochError::IllFormedStatQualifier`
    /// is returned.
    fn from_str(s: &str) -> Result<Self, Self::Err> {
        let (stat_str, val_str) = if let Some(idx) = s.find([':', '=']) {
            (&s[..idx], &s[idx + 1..])
        } else {
            let parts: Vec<&str> = s.split_whitespace().collect();
            if parts.len() != 2 {
                return Err(EpochError::IllFormedStatQualifier(s.to_owned()));
            }
            (parts[0], parts[1])
        };

        let stat: ListStats = stat_str.parse()?;
        let value: isize = val_str
            .parse()
            .map_err(|_| EpochError::IllFormedStatQualifier(val_str.to_owned()))?;
        Ok(StatPair {
            stat,
            value: stats::GenericStat(value),
        })
    }
}

/// Parse a string into a `Position`.
///
/// The input must be two signed integers separated by a comma, optionally
/// surrounded by whitespace.  Leading and trailing whitespace around each
/// component is ignored.
///
/// # Errors
///
/// * `ParsePositionError::InvalidFormat` - the string does not contain
///   exactly one comma or there are not exactly two components.
/// * `ParsePositionError::ParseIntError` - one of the components cannot be
///   parsed as an `isize`.
impl std::str::FromStr for Position {
    type Err = EpochError;

    fn from_str(s: &str) -> Result<Self, Self::Err> {
        let parts: Vec<&str> = s.split(',').collect();
        if parts.len() != 2 {
            return Err(EpochError::InvalidPositionFormat(s.to_string()));
        }
        let x: isize = parts[0]
            .trim()
            .parse()
            .map_err(|_| EpochError::ParsePositionError(s.to_string()))?;
        let y: isize = parts[1]
            .trim()
            .parse()
            .map_err(|_| EpochError::ParsePositionError(s.to_string()))?;
        Ok(Position(x, y))
    }
}

/// Parse a string into a `PositionGrid`.  
///  
/// The string is expected to contain two signed integers separated by a comma,
/// optionally surrounded by whitespace.  Each component is trimmed before
/// parsing, so leading and trailing whitespace is ignored.  
///  
/// The parsing logic is the same as for `Position`:  
/// * Split on the comma; there must be exactly one comma.  
/// * Trim each component and parse it as an `isize`.  
/// * Convert the resulting `Position` to a grid distance with
///   `Position::to_grid_distance`.  
///  
/// # Errors  
///  
/// * `EpochError::InvalidPositionFormat` - the string does not contain
///   exactly one comma or there are not exactly two components.  
/// * `EpochError::ParsePositionError` - one of the components cannot be
///   parsed as an `isize`.  (These errors come from the underlying `Position`
///   implementation.)
impl std::str::FromStr for PositionGrid {
    type Err = EpochError;

    fn from_str(s: &str) -> Result<Self, Self::Err> {
        s.parse::<Position>().map(|p| PositionGrid(p.0, p.1))
    }
}

impl FromStr for PositionIdentifier {
    type Err = EpochError;

    /// Parses a string into one of the three variants.
    ///
    /// The parsing rules are described in the table above.
    fn from_str(s: &str) -> Result<Self, Self::Err> {
        let s = s.trim();

        if let Some(_rest) = s.find('@') {
            let id = s.parse().map_err(|_| EpochError::ParsingArgument {
                argument_parsed: s.to_string(),
                while_parsing: "PositionIdentifier::EpochId",
            })?;
            return Ok(Self::Id(id));
        }

        if let Some(rest) = s.strip_prefix('~').or_else(|| s.strip_prefix('g')) {
            let grid = rest.parse().map_err(|_| EpochError::ParsingArgument {
                argument_parsed: s.to_string(),
                while_parsing: "PositionIdentifier::PositionGrid",
            })?;
            return Ok(Self::Grid(grid));
        }

        let exact = s.parse().map_err(|_| EpochError::ParsingArgument {
            argument_parsed: s.to_string(),
            while_parsing: "PositionIdentifier::Position",
        })?;
        Ok(Self::Exact(exact))
    }
}

/// Convert a tuple of two signed integers into a `Position`.
///
/// This implementation simply wraps the `(isize, isize)` tuple into a
/// `Position` struct. It is equivalent to `Position(x, y)` where `x` is the
/// first element and `y` is the second.
impl From<(isize, isize)> for Position {
    fn from(value: (isize, isize)) -> Self {
        Self(value.0, value.1)
    }
}
/// Convert a tuple of two signed integers into a `PositionGrid`.
///
/// This implementation simply wraps the `(isize, isize)` tuple into a
/// `Position` struct. It is equivalent to `Position(x, y)` where `x` is the
/// first element and `y` is the second.
impl From<(isize, isize)> for PositionGrid {
    fn from(value: (isize, isize)) -> Self {
        Self(value.0, value.1)
    }
}
impl std::str::FromStr for stats::Reach {
    type Err = EpochError; // Clap accepts any type that implements `Display`

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

        match s.as_str() {
            "g" | "global" => return Ok(stats::Reach::Global),
            "n" | "none" => return Ok(stats::Reach::None),
            _ => {}
        }

        if s.starts_with('l') {
            if let Some(idx) = s.find(':') {
                let rad_str = &s[idx + 1..];
                let radius: usize = rad_str.parse().map_err(|_| EpochError::ParsingArgument {
                    argument_parsed: s,
                    while_parsing: "Reach::Local",
                })?;
                return Ok(stats::Reach::Local(radius));
            } else {
                return Err(EpochError::ParsingArgument {
                    argument_parsed: s,
                    while_parsing: "Local reach requires a radius, e.g. `l:5` or `local:5`",
                });
            }
        }

        if s.starts_with('f') {
            if let Some(idx) = s.find(':') {
                let id_str = &s[idx + 1..];
                let id: usize = id_str.parse().map_err(|_| EpochError::ParsingArgument {
                    argument_parsed: s,
                    while_parsing: "Reach::Faction",
                })?;
                return Ok(stats::Reach::Faction(stats::FactionId(id)));
            } else {
                return Err(EpochError::ParsingArgument {
                    argument_parsed: s,
                    while_parsing: "Faction reach requires an id, e.g. `f:3` or `faction:3`",
                });
            }
        }

        Err(EpochError::ParsingArgument {
            argument_parsed: s,
            while_parsing: "Unknown error",
        })
    }
}

impl FromStr for GenericStat {
    type Err = EpochError;

    fn from_str(s: &str) -> Result<Self, Self::Err> {
        s.parse::<isize>()
            .map_err(|_| EpochError::ParsingArgument {
                argument_parsed: s.to_owned(),
                while_parsing: "GenericStat",
            })
            .map(Self)
    }
}

impl std::str::FromStr for stats::Modification {
    type Err = EpochError; // placeholder – you can make a custom error

    fn from_str(s: &str) -> Result<Self, Self::Err> {
        match s.to_ascii_lowercase().as_str() {
            w if w.starts_with("delt") => Ok(stats::Modification::Delta),
            "add" => Ok(stats::Modification::Delta),
            w if w.starts_with("repl") => Ok(stats::Modification::Replace),
            "change" => Ok(stats::Modification::Replace),
            w if w.starts_with("del") => Ok(stats::Modification::Delete),
            _ => Err(EpochError::ParsingArgument {
                argument_parsed: s.to_owned(),
                while_parsing: "Modification",
            }), // trick: convert a bad string into a ParseIntError
        }
    }
}

impl From<bool> for stats::Modification {
    fn from(value: bool) -> Self {
        match value {
            true => stats::Modification::Delta,
            false => stats::Modification::Replace,
        }
    }
}

impl FromStr for FactionId {
    type Err = EpochError; // the error we get from `usize::parse`

    /// Parse a string slice into a `FactionId`.
    fn from_str(s: &str) -> Result<Self, Self::Err> {
        // Trim whitespace just in case and attempt to parse.
        let inner = s
            .trim()
            .parse::<usize>()
            .map_err(|_| EpochError::ParsingArgument {
                argument_parsed: s.to_string(),
                while_parsing: "FactionId",
            })?;
        Ok(FactionId(inner))
    }
}

impl FromStr for ListStats {
    type Err = EpochError;

    /// Convert an acronym (e.g. `"cri"`) into the corresponding enum variant.
    fn from_str(s: &str) -> Result<Self, Self::Err> {
        match s.to_ascii_lowercase().as_str() {
            "dem" | "demog" | "demographics" | "demo" => Ok(ListStats::Demographics),
            "pop" | "popul" | "populations" => Ok(ListStats::Population),
            "grow" | "grw" | "growth" => Ok(ListStats::Growthrate),
            "cri" | "crim" | "crimes" => Ok(ListStats::Crime),
            "hapn" | "happines" | "hap" => Ok(ListStats::Happiness),
            "eco" | "economy" | "econ" => Ok(ListStats::Economy),
            "food" | "fo" | "agr" | "agri" | "fod" => Ok(ListStats::Food),
            "industry" | "indus" | "ind" => Ok(ListStats::Industry),
            "science" | "sci" | "sc" => Ok(ListStats::Science),
            "trade" | "trd" | "tr" => Ok(ListStats::Trade),
            "social" | "soc" | "sl" => Ok(ListStats::Social),
            "culture" | "cul" | "cl" => Ok(ListStats::Culture),
            "education" | "edu" | "ed" => Ok(ListStats::Education),
            "tourism" | "tour" | "tm" => Ok(ListStats::Tourism),
            "influence" | "infl" | "influ" => Ok(ListStats::Influence),
            "military" | "mil" | "mt" => Ok(ListStats::Military),
            "army" | "arm" | "ar" => Ok(ListStats::Army),
            "strength" | "str" | "st" => Ok(ListStats::Strength),
            "fortification" | "fort" | "ft" => Ok(ListStats::Fortification),
            "threat" | "thr" | "th" => Ok(ListStats::Threat),
            "ifr" | "inf" | "infrastructure" | "infra" | "infr" => Ok(ListStats::Infrastructure),
            "bureaucracy" | "bureau" | "bur" => Ok(ListStats::Bureaucracy),
            "transportation" | "trans" | "trns" => Ok(ListStats::Transportation),
            "sprawl" | "spr" | "spra" => Ok(ListStats::Sprawl),
            "health" | "hlth" | "hlt" => Ok(ListStats::Health),
            _ => Err(EpochError::UnknownStatAcronim(s.to_owned())),
        }
    }
}

impl From<ListStats> for &str {
    fn from(value: ListStats) -> Self {
        match value {
            ListStats::Demographics => "demographics",
            ListStats::Population => "population",
            ListStats::Growthrate => "growthrate",
            ListStats::Crime => "crime",
            ListStats::Happiness => "happiness",
            ListStats::Economy => "economy",
            ListStats::Food => "food",
            ListStats::Industry => "industry",
            ListStats::Science => "science",
            ListStats::Trade => "trade",
            ListStats::Social => "social",
            ListStats::Culture => "culture",
            ListStats::Education => "education",
            ListStats::Tourism => "tourism",
            ListStats::Influence => "influence",
            ListStats::Military => "military",
            ListStats::Army => "army",
            ListStats::Strength => "strength",
            ListStats::Fortification => "fortification",
            ListStats::Threat => "threat",
            ListStats::Infrastructure => "infrastructure",
            ListStats::Bureaucracy => "bureaucracy",
            ListStats::Transportation => "transportation",
            ListStats::Sprawl => "sprawl",
            ListStats::Health => "health",
        }
    }
}