Enum Format 

pub enum Format {
    Toml,
    Json,
    Unknown,
}

Supported configuration file formats.

Each variant corresponds to a specific file format and provides parsing capabilities.

Variants

Toml

TOML format (requires toml feature).

Json

JSON format (requires json feature).

Unknown

Unknown or unsupported format.

Implementations

impl Format

pub const fn all() -> &'static [Self]

All supported formats.

pub const fn extension(&self) -> &'static str

Get the file extension for this format.

pub const fn alternate_extensions(&self) -> &'static [&'static str]

Get additional file extensions for this format.

pub const fn mime_type(&self) -> &'static str

Get the MIME type for this format.

pub const fn as_str(&self) -> &'static str

Get the display name for this format.

pub fn from_path(path: &Path) -> Option<Self>

Detect format from a file path.

Examines the file extension to determine the format.

Example

use std::path::Path;
use cfgmatic_source::domain::Format;

let format = Format::from_path(Path::new("config.toml"));
assert_eq!(format, Some(Format::Toml));

pub fn from_extension(ext: &str) -> Option<Self>

Detect format from a file extension.

Example

use cfgmatic_source::domain::Format;

let format = Format::from_extension("toml");
assert_eq!(format, Some(Format::Toml));

pub fn from_content(content: &str) -> Option<Self>

Detect format from content by examining the beginning.

This is a heuristic and may not always be accurate.

Example

use cfgmatic_source::domain::Format;

let content = r#"{ "server": { "host": "localhost" } }"#;
let format = Format::from_content(content);
assert_eq!(format, Some(Format::Json));

pub fn parse(&self, content: &str) -> Result<ParsedContent>

Parse content string into a generic value.

Errors

Returns a SourceError::ParseFailed if parsing fails.

Example

use cfgmatic_source::domain::Format;

let content = r#"host = "localhost""#;
let parsed = Format::Toml.parse(content)?;

pub fn parse_as<T: DeserializeOwned>(&self, content: &str) -> Result<T>

Parse content into a specific type.

Errors

Returns a SourceError::ParseFailed if parsing or deserialization fails.

Example

use cfgmatic_source::domain::Format;
use serde::Deserialize;

#[derive(Deserialize)]
struct Config {
    host: String,
}

let content = r#"host = "localhost""#;
let config: Config = Format::Toml.parse_as(content)?;

pub const fn is_known(&self) -> bool

Check if this format is known (not Unknown).

pub const fn is_binary(&self) -> bool

Check if this format is binary.

All currently supported formats are text-based.

Trait Implementations

impl Clone for Format

fn clone(&self) -> Format

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Format

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

Formats the value using the given formatter.

impl Default for Format

fn default() -> Self

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for Format

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for Format

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

Formats the value using the given formatter.

impl Hash for Format

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for Format

fn eq(&self, other: &Format) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for Format

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Copy for Format

impl Eq for Format

impl StructuralPartialEq for Format