Struct Config

pub struct Config {
    pub sections: BTreeMap<String, BTreeMap<String, String>>,
    pub general_values: BTreeMap<String, String>,
}

Fields

sections: BTreeMap<String, BTreeMap<String, String>>

general_values: BTreeMap<String, String>

Implementations

impl Config

pub fn general(&self) -> &BTreeMap<String, String>

pub fn get(&self, section: Option<&str>, key: &str) -> Option<&String>

Examples found in repository

examples/get_values.rs (line 27)

fn main() {
    let config = Config::load_or_default("get-values.ini", || sectioned_defaults! {
        {
            "console" => "true",
            "log_level" => "info",
        }
        ["Server"] {
            "address" => "127.0.0.1",
            "port" => "8080",
            "threads" => "4",
        }
    });

    let console = config
        .get_as::<bool>(None, "console")
        .unwrap();
    let log_level = config
        .get(None, "log_level")
        .unwrap();

    let server_settings = ServerSettings::from_section(&config.section("Server").unwrap()).unwrap();

    println!("General:\n    console={:?}\n    log_level={:?}", console, log_level);
    println!("Server:\n    address={:?}\n    port={:?}\n    threads={:?}", server_settings.address, server_settings.port, server_settings.threads);
}

pub fn get_as<T>(&self, section: Option<&str>, key: &str) -> Option<T>

where T: FromStr + Debug,

Examples found in repository

examples/get_values.rs (line 24)

fn main() {
    let config = Config::load_or_default("get-values.ini", || sectioned_defaults! {
        {
            "console" => "true",
            "log_level" => "info",
        }
        ["Server"] {
            "address" => "127.0.0.1",
            "port" => "8080",
            "threads" => "4",
        }
    });

    let console = config
        .get_as::<bool>(None, "console")
        .unwrap();
    let log_level = config
        .get(None, "log_level")
        .unwrap();

    let server_settings = ServerSettings::from_section(&config.section("Server").unwrap()).unwrap();

    println!("General:\n    console={:?}\n    log_level={:?}", console, log_level);
    println!("Server:\n    address={:?}\n    port={:?}\n    threads={:?}", server_settings.address, server_settings.port, server_settings.threads);
}

pub fn load(filename: &str) -> Result<Self, Error>

pub fn load_or_default<F: FnOnce() -> Config>( filename: &str, default: F, ) -> Self

Examples found in repository

examples/load_file.rs (lines 11-16)

fn main() {
    let filename = "load-file.ini";

    // If you want to handle errors manually, use Config::load() instead.
    // Returns Result<config_tools::Config, config_tools::Error>
    // let config = Config::load(filename);

    // Load and use defaults on failure
    let config = Config::load_or_default(filename, || sectioned_defaults! {
        {
            "host" => "127.0.0.1",
            "port" => "8080",
        }
    });

    config.save(filename).expect("Failed to save config.");

    println!("{config:#?}");
}

examples/get_values.rs (lines 11-21)

fn main() {
    let config = Config::load_or_default("get-values.ini", || sectioned_defaults! {
        {
            "console" => "true",
            "log_level" => "info",
        }
        ["Server"] {
            "address" => "127.0.0.1",
            "port" => "8080",
            "threads" => "4",
        }
    });

    let console = config
        .get_as::<bool>(None, "console")
        .unwrap();
    let log_level = config
        .get(None, "log_level")
        .unwrap();

    let server_settings = ServerSettings::from_section(&config.section("Server").unwrap()).unwrap();

    println!("General:\n    console={:?}\n    log_level={:?}", console, log_level);
    println!("Server:\n    address={:?}\n    port={:?}\n    threads={:?}", server_settings.address, server_settings.port, server_settings.threads);
}

pub fn builder() -> ConfigBuilder

Examples found in repository

examples/general_manual.rs (line 4)

fn main() {
    let config = Config::builder()
        .set("host", "127.0.0.1")
        .set("port", "8080")
        .build();

    config
        .save("general-manual.ini")
        .expect("Failed to save config.");

    println!("{:#?}", config);
}

examples/sectioned_manual.rs (line 4)

fn main() {
    let config = Config::builder()
        .section("Server")
        .set("host", "127.0.0.1")
        .set("port", "8080")
        .section("Window")
        .set("width", "720")
        .set("height", "480")
        .general()
        .set("console", "true")
        .build();

    config
        .save("sectioned-manual.ini")
        .expect("Failed to save config.");

    println!("{:#?}", config);
}

pub fn save(&self, filename: &str) -> Result<&Self, Error>

Examples found in repository

examples/general_macro.rs (line 8)

fn main() {
    let config = config_tools::general_defaults! {
        "host" => "127.0.0.1",
        "port" => "8080",
    };

    config
        .save("general-manual.ini")
        .expect("Failed to save config.");

    println!("{:#?}", config);
}

examples/general_manual.rs (line 10)

fn main() {
    let config = Config::builder()
        .set("host", "127.0.0.1")
        .set("port", "8080")
        .build();

    config
        .save("general-manual.ini")
        .expect("Failed to save config.");

    println!("{:#?}", config);
}

examples/sectioned_manual.rs (line 16)

fn main() {
    let config = Config::builder()
        .section("Server")
        .set("host", "127.0.0.1")
        .set("port", "8080")
        .section("Window")
        .set("width", "720")
        .set("height", "480")
        .general()
        .set("console", "true")
        .build();

    config
        .save("sectioned-manual.ini")
        .expect("Failed to save config.");

    println!("{:#?}", config);
}

examples/sectioned_macro.rs (line 19)

fn main() {
    let config = config_tools::sectioned_defaults! {
        {
            "console" => "true"
        }

        ["Application"] {
            "host" => "127.0.0.1",
            "port" => "8080",
        }

        ["Window"] {
            "width" => "720",
            "height" => "480",
        }
    };

    config
        .save("sectioned-macro.ini")
        .expect("Failed to save config.");

    println!("{:#?}", config);
}

examples/load_file.rs (line 18)

fn main() {
    let filename = "load-file.ini";

    // If you want to handle errors manually, use Config::load() instead.
    // Returns Result<config_tools::Config, config_tools::Error>
    // let config = Config::load(filename);

    // Load and use defaults on failure
    let config = Config::load_or_default(filename, || sectioned_defaults! {
        {
            "host" => "127.0.0.1",
            "port" => "8080",
        }
    });

    config.save(filename).expect("Failed to save config.");

    println!("{config:#?}");
}

pub fn section(&self, title: &str) -> Option<&BTreeMap<String, String>>

Examples found in repository

examples/get_values.rs (line 30)

fn main() {
    let config = Config::load_or_default("get-values.ini", || sectioned_defaults! {
        {
            "console" => "true",
            "log_level" => "info",
        }
        ["Server"] {
            "address" => "127.0.0.1",
            "port" => "8080",
            "threads" => "4",
        }
    });

    let console = config
        .get_as::<bool>(None, "console")
        .unwrap();
    let log_level = config
        .get(None, "log_level")
        .unwrap();

    let server_settings = ServerSettings::from_section(&config.section("Server").unwrap()).unwrap();

    println!("General:\n    console={:?}\n    log_level={:?}", console, log_level);
    println!("Server:\n    address={:?}\n    port={:?}\n    threads={:?}", server_settings.address, server_settings.port, server_settings.threads);
}

pub fn sections(&self) -> &BTreeMap<String, BTreeMap<String, String>>

pub fn update( &mut self, section: Option<&str>, key: &str, value: &str, ) -> &mut Self

Trait Implementations

impl Debug for Config

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

Formats the value using the given formatter.

impl Default for Config

fn default() -> Config

Returns the “default value” for a type.

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.