Struct Config 

pub struct Config {
    pub schema: Option<String>,
    pub modeling: ModelingConfig,
    pub training: TrainingConfig,
    pub upper_bound_evaluation: UpperBoundEvaluationConfig,
    pub policy: PolicyConfig,
    pub simulation: SimulationConfig,
    pub exports: ExportsConfig,
    pub estimation: EstimationConfig,
}

Top-level deserialized representation of config.json.

All sections except training are optional; their defaults are applied by serde when the section is absent from the JSON.

Fields

schema: Option<String>

JSON schema URI — informational, not validated.

modeling: ModelingConfig

Modeling options (inflow non-negativity treatment).

training: TrainingConfig

Training parameters — contains mandatory fields.

upper_bound_evaluation: UpperBoundEvaluationConfig

Upper-bound evaluation via inner approximation.

policy: PolicyConfig

Policy directory settings (warm-start / resume).

simulation: SimulationConfig

Post-training simulation settings.

exports: ExportsConfig

Export flags controlling which outputs are written to disk.

estimation: EstimationConfig

Time series estimation settings for automatic model parameter fitting.

Implementations

impl Config

pub fn training_scenario_source( &self, path: &Path, ) -> Result<ScenarioSource, LoadError>

Resolve the training-phase ScenarioSource.

When training.scenario_source is absent, returns ScenarioSource::default() (all classes InSample, no seed, no historical years).

Errors

Returns LoadError::SchemaError if the raw config contains an invalid scheme string, Historical on a non-inflow class, or seed/year validation failures.

Examples

use cobre_io::config::parse_config;
use std::path::Path;

let cfg = parse_config(Path::new("case/config.json")).unwrap();
let source = cfg.training_scenario_source(Path::new("case/config.json")).unwrap();

pub fn simulation_scenario_source( &self, path: &Path, ) -> Result<ScenarioSource, LoadError>

Resolve the simulation-phase ScenarioSource.

Falls back to training_scenario_source() when simulation.scenario_source is absent.

Errors

Returns LoadError::SchemaError on validation failures in either the simulation or training scenario source.

Examples

use cobre_io::config::parse_config;
use std::path::Path;

let cfg = parse_config(Path::new("case/config.json")).unwrap();
let source = cfg.simulation_scenario_source(Path::new("case/config.json")).unwrap();

pub fn training_openings(&self) -> Option<&Openings>

The training-phase openings source declaration, or None when absent (equivalent to generated). Single owner of the training openings lookup that downstream opening-tree selection reads.

pub fn resolve_forward_passes(&self) -> Option<ForwardPassesResolution>

Resolve the effective training forward-pass method from training.selection.

Returns None when selection is absent, leaving the mandatory-count rejection to [validate_config]. An enumerated selection resolves to ForwardPassesResolution::Enumerated — config load holds no policy graph, so the count itself is derived downstream.

pub fn resolve_num_scenarios(&self) -> NumScenariosResolution

Resolve the effective simulation scenario-count method from simulation.selection, defaulting to [DEFAULT_NUM_SCENARIOS] when absent.

An enumerated selection resolves to NumScenariosResolution::Enumerated — config load holds no policy graph, so the derived count happens downstream.

pub fn with_overrides( base: &Value, overrides: &Map<String, Value>, ) -> Result<Config, LoadError>

Deep-merge a flat map of dotted-key overrides into base and re-deserialize the result into a validated Config.

base is the parsed-but-not-typed config.json (a serde_json::Value::Object). overrides is a flat map whose keys are dotted paths into the config schema (e.g. "training.tree_seed", "policy.checkpointing.compress"). Intermediate objects are reused rather than replaced, so setting policy.checkpointing.compress does not clobber sibling keys under policy or policy.checkpointing.

After merging, the value is re-deserialized into Config. Because Config is #[serde(deny_unknown_fields)], an override key that does not exist in the schema (a typo such as trainning.tree_seed) fails loudly. The same post-deserialization checks as parse_config then run via validate_config.

All errors carry the synthetic path "<config_overrides>" so callers can recognize override-originated failures.

Errors

• LoadError::SchemaError if base is not a JSON object.
• LoadError::SchemaError if any override key contains an empty path segment (e.g. "training..seed" or a leading/trailing dot).
• LoadError::SchemaError if the merged value fails to deserialize into Config (e.g. an unknown field) or fails validate_config.

Trait Implementations

impl Clone for Config

fn clone(&self) -> Config

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Config

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Config

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for Config

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.