Struct Vdf 

pub struct Vdf<'text> { /* private fields */ }

Top-level VDF document

A VDF document is essentially a single key-value pair at the root level.

Implementations

impl<'text> Vdf<'text>

pub fn new(key: impl Into<Cow<'text, str>>, value: Value<'text>) -> Self

Creates a new VDF document.

pub fn key(&self) -> &str

Returns the root key.

Examples found in repository

examples/verify_compactified.rs (line 29)

fn main() {
    let args: Vec<String> = env::args().collect();

    if args.len() < 2 {
        eprintln!("Usage: {} <vdf_file>", args[0]);
        std::process::exit(1);
    }

    let path = &args[1];

    // Read the file
    let data = match std::fs::read(path) {
        Ok(d) => d,
        Err(e) => {
            eprintln!("Error reading file: {}", e);
            std::process::exit(1);
        }
    };

    // Parse it
    match parse_appinfo(&data) {
        Ok(vdf) => {
            println!("Successfully parsed {}", path);
            println!("Root key: {}", vdf.key());
            if let Some(obj) = vdf.as_obj() {
                println!("Number of apps: {}", obj.len());
                for (key, _) in obj.iter().take(5) {
                    println!("  - app_id: {}", key);
                }
                if obj.len() > 5 {
                    println!("  ... and {} more", obj.len() - 5);
                }
            }
        }
        Err(e) => {
            eprintln!("Error parsing file: {:?}", e);
            std::process::exit(1);
        }
    }
}

examples/test_parse_real.rs (line 14)

fn main() {
    // Test localconfig.vdf (text format)
    println!("=== Parsing localconfig.vdf (text format) ===");
    let localconfig = fs::read_to_string(
        "/home/mexus/.local/share/Steam/userdata/127648749/config/localconfig.vdf",
    );
    match localconfig {
        Ok(content) => match parse_text(&content) {
            Ok(vdf) => {
                println!("Success!");
                println!("Root key: {}", vdf.key());
                let obj = vdf.as_obj().unwrap();
                println!("Root has {} keys", obj.len());
            }
            Err(e) => {
                println!("Parse error: {:?}", e);
            }
        },
        Err(e) => println!("Error reading: {}", e),
    }

    println!("\n=== Parsing appinfo.vdf (binary format) ===");
    let appinfo = fs::read("/home/mexus/.local/share/Steam/appcache/appinfo.vdf");
    match appinfo {
        Ok(data) => match parse_binary(&data) {
            Ok(vdf) => {
                println!("Success!");
                println!("Root key: {}", vdf.key());
                let obj = vdf.as_obj().unwrap();
                println!("Root has {} keys", obj.len());
            }
            Err(e) => {
                println!("Parse error: {:?}", e);
            }
        },
        Err(e) => println!("Error reading: {}", e),
    }
}

examples/dump_vdf.rs (line 99)

fn main() {
    let args: Vec<String> = env::args().collect();
    if args.len() < 2 {
        eprintln!("Usage: {} <vdf_file> [--text]", args[0]);
        eprintln!(
            "  --text: force text format parsing (default: auto-detect based on file extension)"
        );
        std::process::exit(1);
    }

    let path = Path::new(&args[1]);
    let force_text = args.len() > 2 && args[2] == "--text";

    let result = if force_text || path.extension().is_some_and(|e| e == "vdf") {
        // Try text first for .vdf files
        let content = std::fs::read_to_string(path);
        if let Ok(content) = content {
            parse_text(&content).map(|v| v.into_owned())
        } else {
            // Fall back to binary
            let data = std::fs::read(path).expect("Failed to read file");
            if path
                .file_name()
                .is_some_and(|n| n.to_str().is_some_and(|s| s.contains("packageinfo")))
            {
                binary::parse_packageinfo(&data).map(|v| v.into_owned())
            } else if path
                .file_name()
                .is_some_and(|n| n.to_str().is_some_and(|s| s.contains("appinfo")))
            {
                binary::parse_appinfo(&data).map(|v| v.into_owned())
            } else {
                parse_binary(&data).map(|v| v.into_owned())
            }
        }
    } else {
        // Binary parsing
        let data = std::fs::read(path).expect("Failed to read file");
        if path
            .file_name()
            .is_some_and(|n| n.to_str().is_some_and(|s| s.contains("packageinfo")))
        {
            binary::parse_packageinfo(&data).map(|v| v.into_owned())
        } else if path
            .file_name()
            .is_some_and(|n| n.to_str().is_some_and(|s| s.contains("appinfo")))
        {
            binary::parse_appinfo(&data).map(|v| v.into_owned())
        } else {
            parse_binary(&data).map(|v| v.into_owned())
        }
    };

    match result {
        Ok(vdf) => {
            println!("\"{}\" {}", vdf.key(), dump_value(vdf.value(), 0));
        }
        Err(e) => {
            eprintln!("Error parsing VDF: {:?}", e);
            std::process::exit(1);
        }
    }
}

pub fn value(&self) -> &Value<'text>

Returns a reference to the root value.

Examples found in repository

examples/dump_vdf.rs (line 99)

fn main() {
    let args: Vec<String> = env::args().collect();
    if args.len() < 2 {
        eprintln!("Usage: {} <vdf_file> [--text]", args[0]);
        eprintln!(
            "  --text: force text format parsing (default: auto-detect based on file extension)"
        );
        std::process::exit(1);
    }

    let path = Path::new(&args[1]);
    let force_text = args.len() > 2 && args[2] == "--text";

    let result = if force_text || path.extension().is_some_and(|e| e == "vdf") {
        // Try text first for .vdf files
        let content = std::fs::read_to_string(path);
        if let Ok(content) = content {
            parse_text(&content).map(|v| v.into_owned())
        } else {
            // Fall back to binary
            let data = std::fs::read(path).expect("Failed to read file");
            if path
                .file_name()
                .is_some_and(|n| n.to_str().is_some_and(|s| s.contains("packageinfo")))
            {
                binary::parse_packageinfo(&data).map(|v| v.into_owned())
            } else if path
                .file_name()
                .is_some_and(|n| n.to_str().is_some_and(|s| s.contains("appinfo")))
            {
                binary::parse_appinfo(&data).map(|v| v.into_owned())
            } else {
                parse_binary(&data).map(|v| v.into_owned())
            }
        }
    } else {
        // Binary parsing
        let data = std::fs::read(path).expect("Failed to read file");
        if path
            .file_name()
            .is_some_and(|n| n.to_str().is_some_and(|s| s.contains("packageinfo")))
        {
            binary::parse_packageinfo(&data).map(|v| v.into_owned())
        } else if path
            .file_name()
            .is_some_and(|n| n.to_str().is_some_and(|s| s.contains("appinfo")))
        {
            binary::parse_appinfo(&data).map(|v| v.into_owned())
        } else {
            parse_binary(&data).map(|v| v.into_owned())
        }
    };

    match result {
        Ok(vdf) => {
            println!("\"{}\" {}", vdf.key(), dump_value(vdf.value(), 0));
        }
        Err(e) => {
            eprintln!("Error parsing VDF: {:?}", e);
            std::process::exit(1);
        }
    }
}

pub fn value_mut(&mut self) -> &mut Value<'text>

Returns a mutable reference to the root value.

pub fn into_parts(self) -> (Cow<'text, str>, Value<'text>)

Consumes the Vdf and returns its parts.

pub fn is_obj(&self) -> bool

Returns true if the root value is an object.

pub fn as_obj(&self) -> Option<&Obj<'text>>

Returns a reference to the root object if it is one.

Examples found in repository

examples/verify_compactified.rs (line 30)

fn main() {
    let args: Vec<String> = env::args().collect();

    if args.len() < 2 {
        eprintln!("Usage: {} <vdf_file>", args[0]);
        std::process::exit(1);
    }

    let path = &args[1];

    // Read the file
    let data = match std::fs::read(path) {
        Ok(d) => d,
        Err(e) => {
            eprintln!("Error reading file: {}", e);
            std::process::exit(1);
        }
    };

    // Parse it
    match parse_appinfo(&data) {
        Ok(vdf) => {
            println!("Successfully parsed {}", path);
            println!("Root key: {}", vdf.key());
            if let Some(obj) = vdf.as_obj() {
                println!("Number of apps: {}", obj.len());
                for (key, _) in obj.iter().take(5) {
                    println!("  - app_id: {}", key);
                }
                if obj.len() > 5 {
                    println!("  ... and {} more", obj.len() - 5);
                }
            }
        }
        Err(e) => {
            eprintln!("Error parsing file: {:?}", e);
            std::process::exit(1);
        }
    }
}

examples/test_parse_real.rs (line 15)

fn main() {
    // Test localconfig.vdf (text format)
    println!("=== Parsing localconfig.vdf (text format) ===");
    let localconfig = fs::read_to_string(
        "/home/mexus/.local/share/Steam/userdata/127648749/config/localconfig.vdf",
    );
    match localconfig {
        Ok(content) => match parse_text(&content) {
            Ok(vdf) => {
                println!("Success!");
                println!("Root key: {}", vdf.key());
                let obj = vdf.as_obj().unwrap();
                println!("Root has {} keys", obj.len());
            }
            Err(e) => {
                println!("Parse error: {:?}", e);
            }
        },
        Err(e) => println!("Error reading: {}", e),
    }

    println!("\n=== Parsing appinfo.vdf (binary format) ===");
    let appinfo = fs::read("/home/mexus/.local/share/Steam/appcache/appinfo.vdf");
    match appinfo {
        Ok(data) => match parse_binary(&data) {
            Ok(vdf) => {
                println!("Success!");
                println!("Root key: {}", vdf.key());
                let obj = vdf.as_obj().unwrap();
                println!("Root has {} keys", obj.len());
            }
            Err(e) => {
                println!("Parse error: {:?}", e);
            }
        },
        Err(e) => println!("Error reading: {}", e),
    }
}

examples/appid_to_name.rs (line 53)

fn main() -> ExitCode {
    let args: Vec<String> = env::args().collect();

    if args.len() < 2 {
        eprintln!("Usage: {} <path/to/appinfo.vdf>", args[0]);
        eprintln!();
        eprintln!("Extracts AppId to game name mappings from Steam's appinfo.vdf file.");
        eprintln!();
        eprintln!("The appinfo.vdf file is typically located at:");
        eprintln!("  Windows: C:\\Program Files (x86)\\Steam\\appcache\\appinfo.vdf");
        eprintln!("  Linux:   ~/.steam/steam/appcache/appinfo.vdf");
        eprintln!("  macOS:   ~/Library/Application Support/Steam/appcache/appinfo.vdf");
        return ExitCode::FAILURE;
    }

    let path = &args[1];

    // Read the file
    let data = match fs::read(path) {
        Ok(data) => data,
        Err(e) => {
            eprintln!("Error reading file '{}': {}", path, e);
            return ExitCode::FAILURE;
        }
    };

    // Parse the appinfo.vdf file
    let vdf = match parse_appinfo(&data) {
        Ok(vdf) => vdf.into_owned(),
        Err(e) => {
            eprintln!("Error parsing appinfo.vdf: {}", e);
            return ExitCode::FAILURE;
        }
    };

    // Get the root object containing all apps
    let root = match vdf.as_obj() {
        Some(obj) => obj,
        None => {
            eprintln!("Error: root is not an object");
            return ExitCode::FAILURE;
        }
    };

    // Iterate through all apps (keyed by AppID as string)
    let mut apps = Vec::new();

    for (app_id_str, app_value) in root.iter() {
        // Skip non-numeric keys (metadata entries)
        if app_id_str.parse::<u32>().is_err() {
            continue;
        }

        let app_obj = match app_value.as_obj() {
            Some(obj) => obj,
            None => continue,
        };

        // Navigate the nested structure: appinfo -> common -> name
        let name = app_obj
            .get("appinfo")
            .and_then(|v| v.as_obj())
            .and_then(|appinfo| appinfo.get("common"))
            .and_then(|common| common.as_obj())
            .and_then(|common| common.get("name"))
            .and_then(|v| v.as_str());

        if let (Some(name), Ok(app_id)) = (name, app_id_str.parse::<u32>()) {
            apps.push((app_id, name.to_string()));
        }
    }

    // Sort by AppID
    apps.sort_by_key(|(id, _)| *id);

    // Print the results
    println!("AppId\tName");
    println!("------\t{}", "-".repeat(80));
    for (app_id, name) in &apps {
        println!("{}\t{}", app_id, name);
    }

    println!();
    println!("Total games: {}", apps.len());

    ExitCode::SUCCESS
}

pub fn get(&self, key: &str) -> Option<&Value<'text>>

Returns a reference to a nested value by key.

pub fn get_path(&self, path: &[&str]) -> Option<&Value<'text>>

Traverse nested objects by path from the root value.

pub fn get_str(&self, path: &[&str]) -> Option<&str>

Get a string at the given path.

pub fn get_obj(&self, path: &[&str]) -> Option<&Obj<'text>>

Get an object at the given path.

pub fn get_i32(&self, path: &[&str]) -> Option<i32>

Get an i32 at the given path.

pub fn get_u64(&self, path: &[&str]) -> Option<u64>

Get a u64 at the given path.

pub fn get_float(&self, path: &[&str]) -> Option<f32>

Get a float at the given path.

impl Vdf<'_>

pub fn into_owned(self) -> Vdf<'static>

Convert to an owned version (with ’static lifetime).

This creates a new Vdf<'static> with all strings owned, allowing the data to outlive the original input.

Examples found in repository

examples/print.rs (line 29)

fn main() {
    let args: Vec<String> = env::args().collect();
    if args.len() < 2 {
        eprintln!("Usage: {} <vdf_file>", args[0]);
        eprintln!();
        eprintln!("Pretty-prints a VDF file to stdout in valid VDF text format.");
        eprintln!("Supports both text (.vdf) and binary (appinfo.vdf, packageinfo.vdf, shortcuts.vdf) formats.");
        std::process::exit(1);
    }

    let path = Path::new(&args[1]);
    let data = std::fs::read(path).expect("Failed to read file");

    // Try to detect format and parse accordingly
    let result = if let Ok(text) = std::str::from_utf8(&data) {
        // Looks like text, try text parser first
        parse_text(text)
            .map(|v| v.into_owned())
            .or_else(|_| parse_binary(&data).map(|v| v.into_owned()))
    } else {
        // Binary data - detect format from filename
        let filename = path
            .file_name()
            .and_then(|n| n.to_str())
            .unwrap_or_default();

        if filename.contains("packageinfo") {
            binary::parse_packageinfo(&data).map(|v| v.into_owned())
        } else if filename.contains("appinfo") {
            binary::parse_appinfo(&data).map(|v| v.into_owned())
        } else {
            parse_binary(&data).map(|v| v.into_owned())
        }
    };

    match result {
        Ok(vdf) => {
            // Use the pretty-print Display implementation
            println!("{:#}", vdf);
        }
        Err(e) => {
            eprintln!("Error parsing VDF: {:?}", e);
            std::process::exit(1);
        }
    }
}

examples/dump_vdf.rs (line 61)

fn main() {
    let args: Vec<String> = env::args().collect();
    if args.len() < 2 {
        eprintln!("Usage: {} <vdf_file> [--text]", args[0]);
        eprintln!(
            "  --text: force text format parsing (default: auto-detect based on file extension)"
        );
        std::process::exit(1);
    }

    let path = Path::new(&args[1]);
    let force_text = args.len() > 2 && args[2] == "--text";

    let result = if force_text || path.extension().is_some_and(|e| e == "vdf") {
        // Try text first for .vdf files
        let content = std::fs::read_to_string(path);
        if let Ok(content) = content {
            parse_text(&content).map(|v| v.into_owned())
        } else {
            // Fall back to binary
            let data = std::fs::read(path).expect("Failed to read file");
            if path
                .file_name()
                .is_some_and(|n| n.to_str().is_some_and(|s| s.contains("packageinfo")))
            {
                binary::parse_packageinfo(&data).map(|v| v.into_owned())
            } else if path
                .file_name()
                .is_some_and(|n| n.to_str().is_some_and(|s| s.contains("appinfo")))
            {
                binary::parse_appinfo(&data).map(|v| v.into_owned())
            } else {
                parse_binary(&data).map(|v| v.into_owned())
            }
        }
    } else {
        // Binary parsing
        let data = std::fs::read(path).expect("Failed to read file");
        if path
            .file_name()
            .is_some_and(|n| n.to_str().is_some_and(|s| s.contains("packageinfo")))
        {
            binary::parse_packageinfo(&data).map(|v| v.into_owned())
        } else if path
            .file_name()
            .is_some_and(|n| n.to_str().is_some_and(|s| s.contains("appinfo")))
        {
            binary::parse_appinfo(&data).map(|v| v.into_owned())
        } else {
            parse_binary(&data).map(|v| v.into_owned())
        }
    };

    match result {
        Ok(vdf) => {
            println!("\"{}\" {}", vdf.key(), dump_value(vdf.value(), 0));
        }
        Err(e) => {
            eprintln!("Error parsing VDF: {:?}", e);
            std::process::exit(1);
        }
    }
}

examples/appid_to_name.rs (line 45)

fn main() -> ExitCode {
    let args: Vec<String> = env::args().collect();

    if args.len() < 2 {
        eprintln!("Usage: {} <path/to/appinfo.vdf>", args[0]);
        eprintln!();
        eprintln!("Extracts AppId to game name mappings from Steam's appinfo.vdf file.");
        eprintln!();
        eprintln!("The appinfo.vdf file is typically located at:");
        eprintln!("  Windows: C:\\Program Files (x86)\\Steam\\appcache\\appinfo.vdf");
        eprintln!("  Linux:   ~/.steam/steam/appcache/appinfo.vdf");
        eprintln!("  macOS:   ~/Library/Application Support/Steam/appcache/appinfo.vdf");
        return ExitCode::FAILURE;
    }

    let path = &args[1];

    // Read the file
    let data = match fs::read(path) {
        Ok(data) => data,
        Err(e) => {
            eprintln!("Error reading file '{}': {}", path, e);
            return ExitCode::FAILURE;
        }
    };

    // Parse the appinfo.vdf file
    let vdf = match parse_appinfo(&data) {
        Ok(vdf) => vdf.into_owned(),
        Err(e) => {
            eprintln!("Error parsing appinfo.vdf: {}", e);
            return ExitCode::FAILURE;
        }
    };

    // Get the root object containing all apps
    let root = match vdf.as_obj() {
        Some(obj) => obj,
        None => {
            eprintln!("Error: root is not an object");
            return ExitCode::FAILURE;
        }
    };

    // Iterate through all apps (keyed by AppID as string)
    let mut apps = Vec::new();

    for (app_id_str, app_value) in root.iter() {
        // Skip non-numeric keys (metadata entries)
        if app_id_str.parse::<u32>().is_err() {
            continue;
        }

        let app_obj = match app_value.as_obj() {
            Some(obj) => obj,
            None => continue,
        };

        // Navigate the nested structure: appinfo -> common -> name
        let name = app_obj
            .get("appinfo")
            .and_then(|v| v.as_obj())
            .and_then(|appinfo| appinfo.get("common"))
            .and_then(|common| common.as_obj())
            .and_then(|common| common.get("name"))
            .and_then(|v| v.as_str());

        if let (Some(name), Ok(app_id)) = (name, app_id_str.parse::<u32>()) {
            apps.push((app_id, name.to_string()));
        }
    }

    // Sort by AppID
    apps.sort_by_key(|(id, _)| *id);

    // Print the results
    println!("AppId\tName");
    println!("------\t{}", "-".repeat(80));
    for (app_id, name) in &apps {
        println!("{}\t{}", app_id, name);
    }

    println!();
    println!("Total games: {}", apps.len());

    ExitCode::SUCCESS
}

Trait Implementations

impl<'text> Clone for Vdf<'text>

fn clone(&self) -> Vdf<'text>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<'text> Debug for Vdf<'text>

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

Formats the value using the given formatter.

impl<'text> Display for Vdf<'text>

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

Formats the value using the given formatter.

impl<'text> PartialEq for Vdf<'text>

fn eq(&self, other: &Vdf<'text>) -> 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<'text> StructuralPartialEq for Vdf<'text>