Struct SymLibTableFile 

pub struct SymLibTableFile;

Implementations

impl SymLibTableFile

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

Examples found in repository

examples/symlib_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 = SymLibTableFile::read(&in_path).map_err(|e| e.to_string())?;
    doc.set_version(7)
        .rename_library("S", "S_EDITED")
        .add_library("Extra", "${KIPRJMOD}/Extra.kicad_sym");

    doc.write(&out_path).map_err(|e| e.to_string())?;
    let reread = SymLibTableFile::read(&out_path).map_err(|e| e.to_string())?;

    println!("input: {}", in_path.display());
    println!("output: {}", out_path.display());
    println!("library_count: {}", reread.ast().library_count);
    println!(
        "first_library_name: {:?}",
        reread.ast().libraries.first().and_then(|l| l.name.clone())
    );
    println!("unknown_nodes: {}", reread.ast().unknown_nodes.len());

    Ok(())
}

examples/read_all.rs (line 30)

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/symlib_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_symlib_files(&input_dir, &mut files)?;
    files.sort();

    if files.is_empty() {
        return Err(format!(
            "no sym-lib-table 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 = SymLibTableFile::read(&path).map_err(|e| format!("read: {e}"))?;
            doc.write(&out_path).map_err(|e| format!("write: {e}"))?;
            let _ = SymLibTableFile::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(())
}