Enum Command 

#[non_exhaustive]
pub(super) enum Command {
    Sim {
        spec: SpecId,
        duration: f64,
        iterations: u32,
        threads: Option<usize>,
        seed: Option<u64>,
        format: OutputFormat,
        rotation: Option<PathBuf>,
    },
    Validate {
        rotation: PathBuf,
        spec: Option<SpecId>,
    },
    Inspect {
        spec: SpecId,
        format: OutputFormat,
        id: Option<u32>,
    },
    Audit {
        manifests: Option<PathBuf>,
    },
    Version,
}

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

Sim

Run a simulation.

Fields

spec: SpecId

Spec to simulate (manifest slug, e.g. beast_mastery_hunter).

duration: f64

Fight duration in seconds.

iterations: u32

Number of iterations.

threads: Option<usize>

Number of threads (defaults to available cores).

seed: Option<u64>

Random seed.

format: OutputFormat

Output format (text or json).

rotation: Option<PathBuf>

Path to rotation JSON file.

Validate

Validate a rotation file.

Fields

rotation: PathBuf

Path to rotation JSON file.

spec: Option<SpecId>

Spec to validate against.

Inspect

Inspect a spec’s resolved spells, auras, and resources.

Fields

spec: SpecId

Spec to inspect.

format: OutputFormat

Output format (text or json).

id: Option<u32>

Filter by spell or aura ID.

Audit

Audit all manifests against game data.

Fields

manifests: Option<PathBuf>

Path to manifests directory (auto-detected if omitted).

Version

Show version info.

Trait Implementations

impl Debug for Command

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl FromArgMatches for Command

fn from_arg_matches(__clap_arg_matches: &ArgMatches) -> Result<Self, Error>

Instantiate Self from [ArgMatches], parsing the arguments as needed.

fn from_arg_matches_mut( __clap_arg_matches: &mut ArgMatches, ) -> Result<Self, Error>

Instantiate Self from [ArgMatches], parsing the arguments as needed.

fn update_from_arg_matches( &mut self, __clap_arg_matches: &ArgMatches, ) -> Result<(), Error>

Assign values from ArgMatches to self.

fn update_from_arg_matches_mut<'b>( &mut self, __clap_arg_matches: &mut ArgMatches, ) -> Result<(), Error>

Assign values from ArgMatches to self.

impl Subcommand for Command

fn augment_subcommands<'b>(__clap_app: Command) -> Command

Append to [Command] so it can instantiate Self via [FromArgMatches::from_arg_matches_mut]

fn augment_subcommands_for_update<'b>(__clap_app: Command) -> Command

Append to [Command] so it can instantiate self via [FromArgMatches::update_from_arg_matches_mut]

fn has_subcommand(__clap_name: &str) -> bool

Test whether Self can parse a specific subcommand