Struct WorksheetFile 

pub struct WorksheetFile;

Implementations

impl WorksheetFile

pub fn read<P: AsRef<Path>>(path: P) -> Result<WorksheetDocument, Error>

Examples found in repository

examples/worksheet_roundtrip.rs (line 15)

fn main() -> Result<(), String> {
    let mut args = env::args().skip(1);
    let in_path = args.next().map(PathBuf::from).ok_or_else(usage)?;
    let out_path = args.next().map(PathBuf::from).ok_or_else(usage)?;

    let mut doc = WorksheetFile::read(&in_path).map_err(|e| e.to_string())?;
    doc.set_version(20260101)
        .set_generator("kiutils")
        .set_generator_version("roundtrip-demo")
        .set_setup_line_width(0.2);
    doc.write(&out_path).map_err(|e| e.to_string())?;

    let reread = WorksheetFile::read(&out_path).map_err(|e| e.to_string())?;
    println!("input: {}", in_path.display());
    println!("output: {}", out_path.display());
    println!("line_count: {}", reread.ast().line_count);
    println!("rect_count: {}", reread.ast().rect_count);
    println!("tbtext_count: {}", reread.ast().tbtext_count);
    println!("unknown_nodes: {}", reread.ast().unknown_nodes.len());
    println!("diagnostics: {}", reread.diagnostics().len());

    Ok(())
}

examples/read_all.rs (line 40)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let base = PathBuf::from(env!("CARGO_MANIFEST_DIR"))
        .join("examples")
        .join("data");

    let pcb = PcbFile::read(base.join("sample.kicad_pcb"))?;
    println!("pcb version: {:?}", pcb.ast().version);
    println!("pcb unknown nodes: {}", pcb.ast().unknown_nodes.len());

    let footprint = FootprintFile::read(base.join("sample.kicad_mod"))?;
    println!("footprint version: {:?}", footprint.ast().version);

    let schematic = SchematicFile::read(base.join("sample.kicad_sch"))?;
    println!("schematic version: {:?}", schematic.ast().version);
    println!(
        "schematic unknown nodes: {}",
        schematic.ast().unknown_nodes.len()
    );

    let table = FpLibTableFile::read(base.join("fp-lib-table"))?;
    println!("fp libs: {}", table.ast().library_count);

    let sym_table = SymLibTableFile::read(base.join("sym-lib-table"))?;
    println!("sym libs: {}", sym_table.ast().library_count);

    let dru = DesignRulesFile::read(base.join("sample.kicad_dru"))?;
    println!("rules: {}", dru.ast().rule_count);
    println!("rule constraints: {}", dru.ast().total_constraint_count);

    let project = ProjectFile::read(base.join("sample.kicad_pro"))?;
    println!("project meta version: {:?}", project.ast().meta_version);

    let worksheet = WorksheetFile::read(base.join("sample.kicad_wks"))?;
    println!("worksheet version: {:?}", worksheet.ast().version);
    println!("worksheet tbtext count: {}", worksheet.ast().tbtext_count);

    pcb.write_mode("/tmp/out.kicad_pcb", WriteMode::Lossless)?;
    Ok(())
}

examples/worksheet_corpus_roundtrip.rs (line 53)

fn main() -> Result<(), String> {
    let mut args = std::env::args().skip(1);
    let input_dir = args.next().map(PathBuf::from).ok_or_else(usage)?;
    let output_dir = args.next().map(PathBuf::from).ok_or_else(usage)?;

    let mut files = Vec::new();
    collect_worksheet_files(&input_dir, &mut files)?;
    files.sort();

    if files.is_empty() {
        return Err(format!(
            "no .kicad_wks files found under {}",
            input_dir.display()
        ));
    }

    let mut ok = 0usize;
    let mut failed = 0usize;
    for path in files {
        let rel = path
            .strip_prefix(&input_dir)
            .map_err(|e| format!("strip_prefix {}: {e}", path.display()))?;
        let out_path = output_dir.join(rel);
        if let Some(parent) = out_path.parent() {
            fs::create_dir_all(parent)
                .map_err(|e| format!("create_dir_all {}: {e}", parent.display()))?;
        }

        let result = (|| -> Result<(), String> {
            let doc = WorksheetFile::read(&path).map_err(|e| format!("read: {e}"))?;
            doc.write(&out_path).map_err(|e| format!("write: {e}"))?;
            let _ = WorksheetFile::read(&out_path).map_err(|e| format!("reread: {e}"))?;
            Ok(())
        })();

        match result {
            Ok(()) => {
                ok += 1;
                println!("ok: {}", path.display());
            }
            Err(err) => {
                failed += 1;
                eprintln!("fail: {} -> {}", path.display(), err);
            }
        }
    }

    println!("summary: ok={ok} failed={failed}");
    if failed > 0 {
        return Err(format!("{failed} files failed"));
    }
    Ok(())
}