Struct Dbc 

pub struct Dbc { /* private fields */ }

Represents a complete DBC (CAN Database) file.

A Dbc contains all the information from a DBC file: version information, node definitions, and CAN messages with their signals.

Examples

use dbc_rs::Dbc;

let content = "VERSION \"1.0\"\n\nBU_: ECM\n\nBO_ 256 Engine : 8 ECM";
let dbc = Dbc::parse(content)?;

Implementations

impl Dbc

pub fn builder() -> DbcBuilder

Create a new builder for constructing a Dbc

Examples

use dbc_rs::{Dbc, Version, Nodes, Message, Signal, ByteOrder, Receivers};

let version = Version::builder().major(1).minor(0).build()?;
let nodes = Nodes::builder().add_node("ECM").add_node("TCM").build()?;

let signal = Signal::builder()
    .name("RPM")
    .start_bit(0)
    .length(16)
    .byte_order(ByteOrder::BigEndian)
    .unsigned(true)
    .factor(0.25)
    .offset(0.0)
    .min(0.0)
    .max(8000.0)
    .unit("rpm")
    .receivers(Receivers::Broadcast)
    .build()?;

let message = Message::builder()
    .id(256)
    .name("EngineData")
    .dlc(8)
    .sender("ECM")
    .add_signal(signal)
    .build()?;

let dbc = Dbc::builder()
    .version(version)
    .nodes(nodes)
    .add_message(message)
    .build()?;

See Also

• parse - Parse from string slice
• Version::builder - Create version using builder
• Nodes::builder - Create nodes using builder
• Message::builder - Create message using builder pattern

Examples found in repository

examples/create_dbc.rs (line 74)

fn main() -> Result<(), dbc_rs::Error> {
    // Create version "1.0" using builder
    let version = Version::builder().major(1).minor(0).build()?;

    // Create nodes: ECM and TCM using builder
    let nodes = Nodes::builder().add_node("ECM").add_node("TCM").build()?;

    // Create signals for Engine message using the builder pattern
    let rpm_signal = Signal::builder()
        .name("RPM")
        .start_bit(0)
        .length(16)
        .byte_order(ByteOrder::LittleEndian)
        .unsigned(true)
        .factor(0.25)
        .offset(0.0)
        .min(0.0)
        .max(8000.0)
        .unit("rpm")
        .receivers(Receivers::None)
        .build()?;

    let temp_signal = Signal::builder()
        .name("Temp")
        .start_bit(16)
        .length(8)
        .byte_order(ByteOrder::LittleEndian)
        .unsigned(false)
        .factor(1.0)
        .offset(-40.0)
        .min(-40.0)
        .max(215.0)
        .unit("°C")
        .receivers(Receivers::None)
        .build()?;

    // Create signals for Brake message
    let pressure_signal = Signal::builder()
        .name("Pressure")
        .start_bit(0)
        .length(16)
        .byte_order(ByteOrder::BigEndian)
        .unsigned(true)
        .factor(0.1)
        .offset(0.0)
        .min(0.0)
        .max(1000.0)
        .unit("bar")
        .receivers(Receivers::None)
        .build()?;

    // Create Engine message (ID 256, DLC 8, sender ECM) using the builder pattern
    let engine_message = Message::builder()
        .id(256)
        .name("Engine")
        .dlc(8)
        .sender("ECM")
        .add_signal(rpm_signal)
        .add_signal(temp_signal)
        .build()?;

    // Create Brake message (ID 512, DLC 4, sender TCM) using the builder pattern
    let brake_message = Message::builder()
        .id(512)
        .name("Brake")
        .dlc(4)
        .sender("TCM")
        .add_signal(pressure_signal)
        .build()?;

    // Create DBC with all components using the builder pattern
    let dbc = Dbc::builder()
        .version(version)
        .nodes(nodes)
        .add_message(engine_message)
        .add_message(brake_message)
        .build()?;

    // Verify the created DBC
    println!("Created DBC with version: {}", dbc.version().to_string());
    println!("Nodes: {}", dbc.nodes().to_string());
    println!("Messages: {}", dbc.messages().len());

    for msg in dbc.messages() {
        println!(
            "  Message {} (ID: {}, DLC: {}, Sender: {})",
            msg.name(),
            msg.id(),
            msg.dlc(),
            msg.sender()
        );
        for sig in msg.signals() {
            println!(
                "    Signal {}: {}|{}@{} (factor: {}, offset: {}) [{:.1}|{:.1}] \"{}\"",
                sig.name(),
                sig.start_bit(),
                sig.length(),
                if sig.byte_order() == ByteOrder::LittleEndian {
                    "0"
                } else {
                    "1"
                },
                sig.factor(),
                sig.offset(),
                sig.min(),
                sig.max(),
                sig.unit().unwrap_or("")
            );
        }
    }

    // The DBC object is now ready to use
    // You can access messages, signals, and other data through the getter methods

    Ok(())
}

pub fn version(&self) -> &Version

Get the version information

Examples found in repository

examples/create_dbc.rs (line 82)

fn main() -> Result<(), dbc_rs::Error> {
    // Create version "1.0" using builder
    let version = Version::builder().major(1).minor(0).build()?;

    // Create nodes: ECM and TCM using builder
    let nodes = Nodes::builder().add_node("ECM").add_node("TCM").build()?;

    // Create signals for Engine message using the builder pattern
    let rpm_signal = Signal::builder()
        .name("RPM")
        .start_bit(0)
        .length(16)
        .byte_order(ByteOrder::LittleEndian)
        .unsigned(true)
        .factor(0.25)
        .offset(0.0)
        .min(0.0)
        .max(8000.0)
        .unit("rpm")
        .receivers(Receivers::None)
        .build()?;

    let temp_signal = Signal::builder()
        .name("Temp")
        .start_bit(16)
        .length(8)
        .byte_order(ByteOrder::LittleEndian)
        .unsigned(false)
        .factor(1.0)
        .offset(-40.0)
        .min(-40.0)
        .max(215.0)
        .unit("°C")
        .receivers(Receivers::None)
        .build()?;

    // Create signals for Brake message
    let pressure_signal = Signal::builder()
        .name("Pressure")
        .start_bit(0)
        .length(16)
        .byte_order(ByteOrder::BigEndian)
        .unsigned(true)
        .factor(0.1)
        .offset(0.0)
        .min(0.0)
        .max(1000.0)
        .unit("bar")
        .receivers(Receivers::None)
        .build()?;

    // Create Engine message (ID 256, DLC 8, sender ECM) using the builder pattern
    let engine_message = Message::builder()
        .id(256)
        .name("Engine")
        .dlc(8)
        .sender("ECM")
        .add_signal(rpm_signal)
        .add_signal(temp_signal)
        .build()?;

    // Create Brake message (ID 512, DLC 4, sender TCM) using the builder pattern
    let brake_message = Message::builder()
        .id(512)
        .name("Brake")
        .dlc(4)
        .sender("TCM")
        .add_signal(pressure_signal)
        .build()?;

    // Create DBC with all components using the builder pattern
    let dbc = Dbc::builder()
        .version(version)
        .nodes(nodes)
        .add_message(engine_message)
        .add_message(brake_message)
        .build()?;

    // Verify the created DBC
    println!("Created DBC with version: {}", dbc.version().to_string());
    println!("Nodes: {}", dbc.nodes().to_string());
    println!("Messages: {}", dbc.messages().len());

    for msg in dbc.messages() {
        println!(
            "  Message {} (ID: {}, DLC: {}, Sender: {})",
            msg.name(),
            msg.id(),
            msg.dlc(),
            msg.sender()
        );
        for sig in msg.signals() {
            println!(
                "    Signal {}: {}|{}@{} (factor: {}, offset: {}) [{:.1}|{:.1}] \"{}\"",
                sig.name(),
                sig.start_bit(),
                sig.length(),
                if sig.byte_order() == ByteOrder::LittleEndian {
                    "0"
                } else {
                    "1"
                },
                sig.factor(),
                sig.offset(),
                sig.min(),
                sig.max(),
                sig.unit().unwrap_or("")
            );
        }
    }

    // The DBC object is now ready to use
    // You can access messages, signals, and other data through the getter methods

    Ok(())
}

pub fn nodes(&self) -> &Nodes

Get the nodes information

Examples found in repository

examples/create_dbc.rs (line 83)

fn main() -> Result<(), dbc_rs::Error> {
    // Create version "1.0" using builder
    let version = Version::builder().major(1).minor(0).build()?;

    // Create nodes: ECM and TCM using builder
    let nodes = Nodes::builder().add_node("ECM").add_node("TCM").build()?;

    // Create signals for Engine message using the builder pattern
    let rpm_signal = Signal::builder()
        .name("RPM")
        .start_bit(0)
        .length(16)
        .byte_order(ByteOrder::LittleEndian)
        .unsigned(true)
        .factor(0.25)
        .offset(0.0)
        .min(0.0)
        .max(8000.0)
        .unit("rpm")
        .receivers(Receivers::None)
        .build()?;

    let temp_signal = Signal::builder()
        .name("Temp")
        .start_bit(16)
        .length(8)
        .byte_order(ByteOrder::LittleEndian)
        .unsigned(false)
        .factor(1.0)
        .offset(-40.0)
        .min(-40.0)
        .max(215.0)
        .unit("°C")
        .receivers(Receivers::None)
        .build()?;

    // Create signals for Brake message
    let pressure_signal = Signal::builder()
        .name("Pressure")
        .start_bit(0)
        .length(16)
        .byte_order(ByteOrder::BigEndian)
        .unsigned(true)
        .factor(0.1)
        .offset(0.0)
        .min(0.0)
        .max(1000.0)
        .unit("bar")
        .receivers(Receivers::None)
        .build()?;

    // Create Engine message (ID 256, DLC 8, sender ECM) using the builder pattern
    let engine_message = Message::builder()
        .id(256)
        .name("Engine")
        .dlc(8)
        .sender("ECM")
        .add_signal(rpm_signal)
        .add_signal(temp_signal)
        .build()?;

    // Create Brake message (ID 512, DLC 4, sender TCM) using the builder pattern
    let brake_message = Message::builder()
        .id(512)
        .name("Brake")
        .dlc(4)
        .sender("TCM")
        .add_signal(pressure_signal)
        .build()?;

    // Create DBC with all components using the builder pattern
    let dbc = Dbc::builder()
        .version(version)
        .nodes(nodes)
        .add_message(engine_message)
        .add_message(brake_message)
        .build()?;

    // Verify the created DBC
    println!("Created DBC with version: {}", dbc.version().to_string());
    println!("Nodes: {}", dbc.nodes().to_string());
    println!("Messages: {}", dbc.messages().len());

    for msg in dbc.messages() {
        println!(
            "  Message {} (ID: {}, DLC: {}, Sender: {})",
            msg.name(),
            msg.id(),
            msg.dlc(),
            msg.sender()
        );
        for sig in msg.signals() {
            println!(
                "    Signal {}: {}|{}@{} (factor: {}, offset: {}) [{:.1}|{:.1}] \"{}\"",
                sig.name(),
                sig.start_bit(),
                sig.length(),
                if sig.byte_order() == ByteOrder::LittleEndian {
                    "0"
                } else {
                    "1"
                },
                sig.factor(),
                sig.offset(),
                sig.min(),
                sig.max(),
                sig.unit().unwrap_or("")
            );
        }
    }

    // The DBC object is now ready to use
    // You can access messages, signals, and other data through the getter methods

    Ok(())
}

pub fn messages(&self) -> &[Message]

Get a read-only slice of messages

Examples found in repository

examples/read_from_sources.rs (line 20)

fn main() -> Result<(), dbc_rs::Error> {
    let dbc_content = r#"VERSION "1.0"

BU_: ECM TCM

BO_ 256 Engine : 8 ECM
 SG_ RPM : 0|16@1+ (0.25,0) [0|8000] "rpm"
 SG_ Temp : 16|8@1- (1,-40) [-40|215] "°C"

BO_ 512 Brake : 4 TCM
 SG_ Pressure : 0|16@1+ (0.1,0) [0|1000] "bar"
"#;

    // Method 1: Parse from string slice (works in no_std)
    println!("1. Parsing from &str:");
    let dbc1 = Dbc::parse(dbc_content)?;
    println!("   Parsed {} messages", dbc1.messages().len());

    // Method 2: Parse from bytes (works in no_std)
    println!("2. Parsing from &[u8]:");
    let bytes = dbc_content.as_bytes();
    let dbc2 = Dbc::parse_bytes(bytes)?;
    println!("   Parsed {} messages", dbc2.messages().len());

    // Method 3: Parse from String (works in no_std)
    println!("3. Parsing from String:");
    let string = String::from(dbc_content);
    let dbc3 = Dbc::parse_from(string)?;
    println!("   Parsed {} messages", dbc3.messages().len());

    // Method 4: Parse from std::io::Read (requires std feature)
    #[cfg(feature = "std")]
    {
        println!("4. Parsing from std::io::Read (Cursor):");
        let cursor = Cursor::new(dbc_content.as_bytes());
        let dbc4 = Dbc::from_reader(cursor)?;
        println!("   Parsed {} messages", dbc4.messages().len());

        // Method 5: Parse from File (requires std feature)
        println!("5. Parsing from File:");
        if let Ok(file) = std::fs::File::open("tests/data/simple.dbc") {
            let dbc5 = Dbc::from_reader(file)?;
            println!("   Parsed {} messages from file", dbc5.messages().len());
        } else {
            println!("   File not found (this is OK for the example)");
        }
    }

    Ok(())
}

examples/create_dbc.rs (line 84)

fn main() -> Result<(), dbc_rs::Error> {
    // Create version "1.0" using builder
    let version = Version::builder().major(1).minor(0).build()?;

    // Create nodes: ECM and TCM using builder
    let nodes = Nodes::builder().add_node("ECM").add_node("TCM").build()?;

    // Create signals for Engine message using the builder pattern
    let rpm_signal = Signal::builder()
        .name("RPM")
        .start_bit(0)
        .length(16)
        .byte_order(ByteOrder::LittleEndian)
        .unsigned(true)
        .factor(0.25)
        .offset(0.0)
        .min(0.0)
        .max(8000.0)
        .unit("rpm")
        .receivers(Receivers::None)
        .build()?;

    let temp_signal = Signal::builder()
        .name("Temp")
        .start_bit(16)
        .length(8)
        .byte_order(ByteOrder::LittleEndian)
        .unsigned(false)
        .factor(1.0)
        .offset(-40.0)
        .min(-40.0)
        .max(215.0)
        .unit("°C")
        .receivers(Receivers::None)
        .build()?;

    // Create signals for Brake message
    let pressure_signal = Signal::builder()
        .name("Pressure")
        .start_bit(0)
        .length(16)
        .byte_order(ByteOrder::BigEndian)
        .unsigned(true)
        .factor(0.1)
        .offset(0.0)
        .min(0.0)
        .max(1000.0)
        .unit("bar")
        .receivers(Receivers::None)
        .build()?;

    // Create Engine message (ID 256, DLC 8, sender ECM) using the builder pattern
    let engine_message = Message::builder()
        .id(256)
        .name("Engine")
        .dlc(8)
        .sender("ECM")
        .add_signal(rpm_signal)
        .add_signal(temp_signal)
        .build()?;

    // Create Brake message (ID 512, DLC 4, sender TCM) using the builder pattern
    let brake_message = Message::builder()
        .id(512)
        .name("Brake")
        .dlc(4)
        .sender("TCM")
        .add_signal(pressure_signal)
        .build()?;

    // Create DBC with all components using the builder pattern
    let dbc = Dbc::builder()
        .version(version)
        .nodes(nodes)
        .add_message(engine_message)
        .add_message(brake_message)
        .build()?;

    // Verify the created DBC
    println!("Created DBC with version: {}", dbc.version().to_string());
    println!("Nodes: {}", dbc.nodes().to_string());
    println!("Messages: {}", dbc.messages().len());

    for msg in dbc.messages() {
        println!(
            "  Message {} (ID: {}, DLC: {}, Sender: {})",
            msg.name(),
            msg.id(),
            msg.dlc(),
            msg.sender()
        );
        for sig in msg.signals() {
            println!(
                "    Signal {}: {}|{}@{} (factor: {}, offset: {}) [{:.1}|{:.1}] \"{}\"",
                sig.name(),
                sig.start_bit(),
                sig.length(),
                if sig.byte_order() == ByteOrder::LittleEndian {
                    "0"
                } else {
                    "1"
                },
                sig.factor(),
                sig.offset(),
                sig.min(),
                sig.max(),
                sig.unit().unwrap_or("")
            );
        }
    }

    // The DBC object is now ready to use
    // You can access messages, signals, and other data through the getter methods

    Ok(())
}

pub fn parse(data: &str) -> Result<Self, Error>

Parse a DBC file from a string slice

This is the core parsing method that works in both std and no_std environments.

Errors

Returns an error if:

• The file is empty
• The version line is missing or invalid
• Nodes are not defined
• Any message or signal fails to parse
• Validation fails (duplicate IDs, invalid senders, etc.)

Examples

use dbc_rs::Dbc;

let content = "VERSION \"1.0\"\n\nBU_: ECM\n\nBO_ 256 Engine : 8 ECM\n SG_ RPM : 0|16@1+ (0.25,0) [0|8000] \"rpm\"";
let dbc = Dbc::parse(content)?;

See Also

• parse_bytes - Parse from bytes
• parse_from - Parse from owned String
• from_reader - Parse from std::io::Read (requires std feature)

Examples found in repository

examples/read_from_sources.rs (line 19)

fn main() -> Result<(), dbc_rs::Error> {
    let dbc_content = r#"VERSION "1.0"

BU_: ECM TCM

BO_ 256 Engine : 8 ECM
 SG_ RPM : 0|16@1+ (0.25,0) [0|8000] "rpm"
 SG_ Temp : 16|8@1- (1,-40) [-40|215] "°C"

BO_ 512 Brake : 4 TCM
 SG_ Pressure : 0|16@1+ (0.1,0) [0|1000] "bar"
"#;

    // Method 1: Parse from string slice (works in no_std)
    println!("1. Parsing from &str:");
    let dbc1 = Dbc::parse(dbc_content)?;
    println!("   Parsed {} messages", dbc1.messages().len());

    // Method 2: Parse from bytes (works in no_std)
    println!("2. Parsing from &[u8]:");
    let bytes = dbc_content.as_bytes();
    let dbc2 = Dbc::parse_bytes(bytes)?;
    println!("   Parsed {} messages", dbc2.messages().len());

    // Method 3: Parse from String (works in no_std)
    println!("3. Parsing from String:");
    let string = String::from(dbc_content);
    let dbc3 = Dbc::parse_from(string)?;
    println!("   Parsed {} messages", dbc3.messages().len());

    // Method 4: Parse from std::io::Read (requires std feature)
    #[cfg(feature = "std")]
    {
        println!("4. Parsing from std::io::Read (Cursor):");
        let cursor = Cursor::new(dbc_content.as_bytes());
        let dbc4 = Dbc::from_reader(cursor)?;
        println!("   Parsed {} messages", dbc4.messages().len());

        // Method 5: Parse from File (requires std feature)
        println!("5. Parsing from File:");
        if let Ok(file) = std::fs::File::open("tests/data/simple.dbc") {
            let dbc5 = Dbc::from_reader(file)?;
            println!("   Parsed {} messages from file", dbc5.messages().len());
        } else {
            println!("   File not found (this is OK for the example)");
        }
    }

    Ok(())
}

pub fn parse_bytes(data: &[u8]) -> Result<Self, Error>

Parse a DBC file from a byte slice

This method accepts &[u8] and converts it to a string for parsing. Works in both std and no_std environments.

Errors

Returns an error if the bytes are not valid UTF-8.

Examples

use dbc_rs::Dbc;

let bytes = b"VERSION \"1.0\"\n\nBU_: ECM\n\nBO_ 256 Engine : 8 ECM\n SG_ RPM : 0|16@1+ (0.25,0) [0|8000] \"rpm\"";
let dbc = Dbc::parse_bytes(bytes)?;

Examples found in repository

examples/read_from_sources.rs (line 25)

fn main() -> Result<(), dbc_rs::Error> {
    let dbc_content = r#"VERSION "1.0"

BU_: ECM TCM

BO_ 256 Engine : 8 ECM
 SG_ RPM : 0|16@1+ (0.25,0) [0|8000] "rpm"
 SG_ Temp : 16|8@1- (1,-40) [-40|215] "°C"

BO_ 512 Brake : 4 TCM
 SG_ Pressure : 0|16@1+ (0.1,0) [0|1000] "bar"
"#;

    // Method 1: Parse from string slice (works in no_std)
    println!("1. Parsing from &str:");
    let dbc1 = Dbc::parse(dbc_content)?;
    println!("   Parsed {} messages", dbc1.messages().len());

    // Method 2: Parse from bytes (works in no_std)
    println!("2. Parsing from &[u8]:");
    let bytes = dbc_content.as_bytes();
    let dbc2 = Dbc::parse_bytes(bytes)?;
    println!("   Parsed {} messages", dbc2.messages().len());

    // Method 3: Parse from String (works in no_std)
    println!("3. Parsing from String:");
    let string = String::from(dbc_content);
    let dbc3 = Dbc::parse_from(string)?;
    println!("   Parsed {} messages", dbc3.messages().len());

    // Method 4: Parse from std::io::Read (requires std feature)
    #[cfg(feature = "std")]
    {
        println!("4. Parsing from std::io::Read (Cursor):");
        let cursor = Cursor::new(dbc_content.as_bytes());
        let dbc4 = Dbc::from_reader(cursor)?;
        println!("   Parsed {} messages", dbc4.messages().len());

        // Method 5: Parse from File (requires std feature)
        println!("5. Parsing from File:");
        if let Ok(file) = std::fs::File::open("tests/data/simple.dbc") {
            let dbc5 = Dbc::from_reader(file)?;
            println!("   Parsed {} messages from file", dbc5.messages().len());
        } else {
            println!("   File not found (this is OK for the example)");
        }
    }

    Ok(())
}

pub fn parse_from<S: AsRef<str>>(data: S) -> Result<Self, Error>

Parse a DBC file from any type that can be converted to a string slice

This is a convenience method that works with String, &str, Box<str>, etc. Works in both std and no_std environments.

Examples

use dbc_rs::Dbc;

let content = String::from("VERSION \"1.0\"\n\nBU_: ECM\n\nBO_ 256 Engine : 8 ECM\n SG_ RPM : 0|16@1+ (0.25,0) [0|8000] \"rpm\"");
let dbc = Dbc::parse_from(content)?;

See Also

• parse - Parse from string slice
• parse_bytes - Parse from bytes
• from_reader - Parse from std::io::Read (requires std feature)

Examples found in repository

examples/read_from_sources.rs (line 31)

fn main() -> Result<(), dbc_rs::Error> {
    let dbc_content = r#"VERSION "1.0"

BU_: ECM TCM

BO_ 256 Engine : 8 ECM
 SG_ RPM : 0|16@1+ (0.25,0) [0|8000] "rpm"
 SG_ Temp : 16|8@1- (1,-40) [-40|215] "°C"

BO_ 512 Brake : 4 TCM
 SG_ Pressure : 0|16@1+ (0.1,0) [0|1000] "bar"
"#;

    // Method 1: Parse from string slice (works in no_std)
    println!("1. Parsing from &str:");
    let dbc1 = Dbc::parse(dbc_content)?;
    println!("   Parsed {} messages", dbc1.messages().len());

    // Method 2: Parse from bytes (works in no_std)
    println!("2. Parsing from &[u8]:");
    let bytes = dbc_content.as_bytes();
    let dbc2 = Dbc::parse_bytes(bytes)?;
    println!("   Parsed {} messages", dbc2.messages().len());

    // Method 3: Parse from String (works in no_std)
    println!("3. Parsing from String:");
    let string = String::from(dbc_content);
    let dbc3 = Dbc::parse_from(string)?;
    println!("   Parsed {} messages", dbc3.messages().len());

    // Method 4: Parse from std::io::Read (requires std feature)
    #[cfg(feature = "std")]
    {
        println!("4. Parsing from std::io::Read (Cursor):");
        let cursor = Cursor::new(dbc_content.as_bytes());
        let dbc4 = Dbc::from_reader(cursor)?;
        println!("   Parsed {} messages", dbc4.messages().len());

        // Method 5: Parse from File (requires std feature)
        println!("5. Parsing from File:");
        if let Ok(file) = std::fs::File::open("tests/data/simple.dbc") {
            let dbc5 = Dbc::from_reader(file)?;
            println!("   Parsed {} messages from file", dbc5.messages().len());
        } else {
            println!("   File not found (this is OK for the example)");
        }
    }

    Ok(())
}

pub fn save(&self) -> String

Serialize the DBC structure back to DBC file format

This method converts a Dbc instance back into a string representation that matches the DBC file format. It uses the to_dbc_string() methods of the individual components (Version, Nodes, Message, Signal) to compose the complete DBC file.

Works in both std and no_std environments.

Examples

use dbc_rs::Dbc;

let content = "VERSION \"1.0\"\n\nBU_: ECM\n\nBO_ 256 Engine : 8 ECM\n SG_ RPM : 0|16@1+ (0.25,0) [0|8000] \"rpm\"";
let dbc = Dbc::parse(content)?;
let saved = dbc.save();
// The saved content should be equivalent to the original

See Also

• parse - Parse a DBC file from string
• Version::to_dbc_string - Serialize version
• Message::to_dbc_string_with_signals - Serialize message

impl Dbc

pub fn from_reader<R: Read>(reader: R) -> Result<Self, Error>

Parse a DBC file from any type implementing std::io::Read

This method reads from files, network streams, in-memory buffers, or any other source that implements std::io::Read. Only available when the std feature is enabled.

Errors

Returns an error if:

• Reading from the source fails
• The data is not valid UTF-8
• The DBC file format is invalid

Examples

use dbc_rs::Dbc;
use std::fs::File;

let file = File::open("example.dbc").expect("file not found");
let dbc = Dbc::from_reader(file).expect("failed to parse");

Reading from a buffer:

use dbc_rs::Dbc;
use std::io::Cursor;

let data = b"VERSION \"1.0\"\n\nBU_: ECM\n\nBO_ 256 Engine : 8 ECM\n SG_ RPM : 0|16@1+ (0.25,0) [0|8000] \"rpm\"";
let cursor = Cursor::new(data);
let dbc = Dbc::from_reader(cursor)?;

See Also

• parse - Parse from string slice (works in no_std)
• parse_bytes - Parse from bytes (works in no_std)
• parse_from - Parse from owned string types (works in no_std)

Examples found in repository

examples/read_from_sources.rs (line 39)

fn main() -> Result<(), dbc_rs::Error> {
    let dbc_content = r#"VERSION "1.0"

BU_: ECM TCM

BO_ 256 Engine : 8 ECM
 SG_ RPM : 0|16@1+ (0.25,0) [0|8000] "rpm"
 SG_ Temp : 16|8@1- (1,-40) [-40|215] "°C"

BO_ 512 Brake : 4 TCM
 SG_ Pressure : 0|16@1+ (0.1,0) [0|1000] "bar"
"#;

    // Method 1: Parse from string slice (works in no_std)
    println!("1. Parsing from &str:");
    let dbc1 = Dbc::parse(dbc_content)?;
    println!("   Parsed {} messages", dbc1.messages().len());

    // Method 2: Parse from bytes (works in no_std)
    println!("2. Parsing from &[u8]:");
    let bytes = dbc_content.as_bytes();
    let dbc2 = Dbc::parse_bytes(bytes)?;
    println!("   Parsed {} messages", dbc2.messages().len());

    // Method 3: Parse from String (works in no_std)
    println!("3. Parsing from String:");
    let string = String::from(dbc_content);
    let dbc3 = Dbc::parse_from(string)?;
    println!("   Parsed {} messages", dbc3.messages().len());

    // Method 4: Parse from std::io::Read (requires std feature)
    #[cfg(feature = "std")]
    {
        println!("4. Parsing from std::io::Read (Cursor):");
        let cursor = Cursor::new(dbc_content.as_bytes());
        let dbc4 = Dbc::from_reader(cursor)?;
        println!("   Parsed {} messages", dbc4.messages().len());

        // Method 5: Parse from File (requires std feature)
        println!("5. Parsing from File:");
        if let Ok(file) = std::fs::File::open("tests/data/simple.dbc") {
            let dbc5 = Dbc::from_reader(file)?;
            println!("   Parsed {} messages from file", dbc5.messages().len());
        } else {
            println!("   File not found (this is OK for the example)");
        }
    }

    Ok(())
}

Trait Implementations

impl Debug for Dbc

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

Formats the value using the given formatter.