Struct AppConfig 

pub struct AppConfig {

    pub import: Vec<String>,
    pub catalogs: Vec<CatalogRef>,
    pub read_catalogs: Vec<Catalog>,
    pub catalog_dir: Option<PathBuf>,
    pub broken_catalogs: Vec<Broken>,
    pub read: ReadConfig,
    pub csv: CsvConfig,
    pub display: DisplayConfig,
    pub performance: PerformanceConfig,
    pub analysis: AnalysisConfig,
    pub chart: ChartConfig,
    pub home: HomeConfig,
    pub cloud: CloudConfig,
    pub http: HttpConfig,
    pub query: QueryConfig,
    pub views: ViewsConfig,
    pub clipboard: ClipboardConfig,
    pub formats: FormatsConfig,
    pub limits: LimitsConfig,
    pub log: LogConfig,
    pub theme: ThemeConfig,
    pub glyphs: GlyphsConfig,
}

Complete application configuration

Fields

import: Vec<String>

Additional config files merged in before this file’s own values.

catalogs: Vec<CatalogRef>

Catalog files elsewhere, listed on the home screen besides catalog.toml and catalogs/: a path, or { path, id, label }.

read_catalogs: Vec<Catalog>

The catalogs read (catalog.toml, then each of catalogs). Not a key: filled by AppConfig::read_catalog_files after merging.

catalog_dir: Option<PathBuf>

The directory catalog.toml was looked for in: the config file’s.

broken_catalogs: Vec<Broken>

Catalog files left out for a mistake, each with what is wrong.

read: ReadConfig

csv: CsvConfig

display: DisplayConfig

performance: PerformanceConfig

analysis: AnalysisConfig

chart: ChartConfig

home: HomeConfig

cloud: CloudConfig

http: HttpConfig

query: QueryConfig

views: ViewsConfig

clipboard: ClipboardConfig

formats: FormatsConfig

limits: LimitsConfig

log: LogConfig

theme: ThemeConfig

glyphs: GlyphsConfig

Implementations

impl AppConfig

pub fn load_with(app_name: &str, overrides: &[Override]) -> Result<Self>

Load configuration from all layers (default, imports, user config), with -c KEY=VALUE over the files.

pub fn load_from_file(config_path: &Path) -> Result<Self>

Load configuration rooted at config_path with its import chain. Layers, lowest first: defaults, each import in order (depth-first), then the file; each changes only the keys it writes. A missing root means defaults; an unreadable root or existing import is an error; a missing import is skipped with a warning (a theme system may not have generated it yet).

pub fn load_from_file_with( config_path: &Path, overrides: &[Override], ) -> Result<Self>

Self::load_from_file, with -c KEY=VALUE laid over every file.

pub fn read_layers( config_path: &Path, overrides: &[Override], ) -> Result<Vec<(LayerSource, ConfigLayer)>>

Every layer of the configuration at config_path, lowest first: imports depth-first, the file, then -c, each named by its origin. A missing root adds nothing.

pub fn from_read_layers( config_path: &Path, overrides: &[Override], layers: &[(LayerSource, ConfigLayer)], ) -> Result<Self>

The configuration layers (from Self::read_layers) describe, merged over defaults and validated.

pub fn from_layers( layers: impl IntoIterator<Item = ConfigLayer>, ) -> Result<Self>

The configuration layers describe, lowest first, over the defaults (resolved once here). Colors start from the built-in theme theme.dark/theme.light names for the declared mode; from_read_layers adds theme files. import is left empty. Not validated.

pub fn read_theme_files(&mut self, config_dir: Option<&Path>) -> Result<()>

Resolve theme.dark and theme.light with config_dir’s themes/ files as well as built-ins. A broken file or unusable name is reported and falls back to the built-in; it never stops startup.

pub fn catalogs(&self) -> Vec<Catalog>

Every catalog, hidden ones included: catalog.toml, the listed files, then the bundled examples (unless a listed examples.toml replaces it).

pub fn shown_catalogs(&self) -> Vec<Catalog>

The catalogs home shows: Self::catalogs less [home] hide (a catalog id, or catalog/id for one entry).

pub fn hides_nothing(name: &str) -> String

Why name in home.hide hides nothing, with the fix when it is the bundled catalog’s old id (public, now examples).

pub fn unknown_hidden(&self) -> Vec<String>

The [home] hide names that match no catalog or entry, each once.

pub fn read_catalog_files(&mut self, config_dir: Option<&Path>) -> Result<()>

Read catalog.toml from config_dir, its catalogs/*.toml by name, and every file catalogs lists. A missing listed file is skipped with a warning (it may be on an unmounted share).

pub fn sync_dataset_access(&mut self)

Derive [cloud]’s view of how catalog URLs are read. Called by from_layers, read_catalog_files and default; call it after changing the catalogs by hand.

pub fn validate(&self) -> Result<()>

Validate configuration values

Trait Implementations

impl Clone for AppConfig

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for AppConfig

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

Formats the value using the given formatter.

impl Default for AppConfig

fn default() -> Self

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for AppConfig

where AppConfig: Default,

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for AppConfig

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

where __S: Serializer,

Serialize this value into the given Serde serializer.