Enum Format 

pub enum Format {
    Json,
    Json5,
    Jsonc,
    Yaml,
    Toon,
    Toml,
    Ini,
}

Supported textual formats for the value-model disassembler.

Variants

Json

Json5

Jsonc

Yaml

Toon

Toml

TOML is intentionally isolated from the JSON-value formats: TOML’s syntactic constraints (no nulls, no array root, bare keys must precede tables) mean conversions through TOML can reorder or fail to represent values produced by JSON/JSON5/JSONC/YAML/TOON. TOML files can therefore only be split into TOML files and reassembled into TOML.

Ini

INI uses the same table-document split layout as TOML, but is even narrower: section values are strings (or valueless keys) and deeper nesting/arrays cannot be represented without inventing an encoding.

Implementations

impl Format

pub const ALL: &'static [Format]

All formats handled by the value-model disassembler.

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

Canonical file extension (without the leading dot).

pub fn canonical_name(self) -> &'static str

Canonical lower-case name used in CLI and metadata.

pub fn display_name(self) -> &'static str

Human-facing display name.

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

Accepted names for CLI parsing.

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

File extensions that identify this format.

pub fn family(self) -> FormatFamily

The conversion family this format belongs to.

pub fn compatible_formats(self) -> &'static [Format]

Formats that can safely convert to/from this format.

pub fn allows_format_overrides(self) -> bool

Whether CLI --input-format / --output-format flags are useful for this subcommand.

pub fn is_cross_format_compatible(self) -> bool

Whether this format participates in cross-format conversions.

pub fn can_convert_to(self, output: Format) -> bool

Whether this format can be converted into output.

pub fn ensure_can_convert_to( self, output: Format, operation: ConversionOperation, ) -> Result<()>

Return a clear error if a conversion edge is not allowed.

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

Best-effort detection of a format from a file path’s extension.

pub fn parse(self, input: &str) -> Result<Value>

Parse a string in this format into a generic Value.

pub fn serialize(self, value: &Value) -> Result<String>

Serialize a Value in this format. The output is always pretty-printed with newline-terminated content.

pub fn load(self, path: &Path) -> Result<Value>

Read and parse a file in this format.

pub fn wrap_split_payload(self, key: &str, value: &Value) -> Value

Prepare a per-key split payload for this format.

Most formats can write the payload value directly. TOML wraps the payload under its parent key so every split file remains a valid TOML table document.

pub fn unwrap_split_payload( self, key: &str, filename: &str, loaded: Value, ) -> Result<Value>

Reverse Format::wrap_split_payload while reassembling.

pub fn supported_format_list() -> String

Canonical CLI names for all registered formats.

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<'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 FromStr for Format

type Err = Error

The associated error which can be returned from parsing.

fn from_str(s: &str) -> Result<Self, Self::Err>

Parses a string s to return a value of this type.

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