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 26)

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(filename: &str, default: Config) -> Self

Examples found in repository

examples/load_file.rs (lines 11-19)

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/from_section.rs (lines 18-35)

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",
                }
                ["LDAP"] {
                    "host" => "ldap://localhost:389",
                    "domain" => "example.com",
                }
        },
    );

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

    println!("{ldap_settings:#?}");
    println!("{server_settings:#?}");
}

examples/get_values.rs (lines 11-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 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 17)

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 21)

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/from_section.rs (line 37)

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",
                }
                ["LDAP"] {
                    "host" => "ldap://localhost:389",
                    "domain" => "example.com",
                }
        },
    );

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

    println!("{ldap_settings:#?}");
    println!("{server_settings:#?}");
}

examples/get_values.rs (line 29)

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 Clone for Config

fn clone(&self) -> Config

Returns a copy 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 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.