dbc-rs 0.5.0

Database CAN (DBC) parsing and editing library
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181

mod helpers;
mod impls;
mod lang;

pub(crate) use helpers::{check_max_limit, map_val_error, map_val_error_with_line};

/// Error type for DBC operations.
///
/// This enum represents all possible errors that can occur when working with DBC files.
/// Parsing errors include line number information to help locate issues in the source file.
#[derive(Debug, PartialEq, Clone)]
pub enum Error {
    /// Unexpected end of input encountered.
    UnexpectedEof { line: Option<usize> },
    /// Expected a specific token or value.
    Expected {
        msg: &'static str,
        line: Option<usize>,
    },
    /// Invalid character encountered.
    InvalidChar { char: char, line: Option<usize> },
    /// String length exceeds the maximum allowed length.
    MaxStrLength { max: usize, line: Option<usize> },
    /// Version-related error.
    Version {
        msg: &'static str,
        line: Option<usize>,
    },
    /// Message-related error.
    Message {
        msg: &'static str,
        line: Option<usize>,
    },
    /// Receivers-related error.
    Receivers {
        msg: &'static str,
        line: Option<usize>,
    },
    /// Nodes-related error.
    Nodes {
        msg: &'static str,
        line: Option<usize>,
    },
    /// Signal-related error.
    Signal {
        msg: &'static str,
        line: Option<usize>,
    },
    /// Decoding-related error (runtime, no line info).
    Decoding(&'static str),
    /// Encoding-related error (runtime, no line info).
    Encoding(&'static str),
    /// Validation-related error (post-parse, no line info).
    Validation(&'static str),
    /// I/O error (std-only, for file operations).
    #[cfg(feature = "std")]
    Io(String),
}

impl Error {
    // ============================================================================
    // Error message constants
    // ============================================================================

    pub const UNEXPECTED_EOF: &'static str = lang::UNEXPECTED_EOF;
    pub const EXPECTED_WHITESPACE: &'static str = lang::EXPECTED_WHITESPACE;
    pub const EXPECTED_PATTERN: &'static str = lang::EXPECTED_PATTERN;
    pub const EXPECTED_KEYWORD: &'static str = lang::EXPECTED_KEYWORD;
    pub const EXPECTED_NUMBER: &'static str = lang::EXPECTED_NUMBER;
    pub const EXPECTED_IDENTIFIER: &'static str = lang::EXPECTED_IDENTIFIER;
    pub const INVALID_UTF8: &'static str = lang::INVALID_UTF8;
    pub const INVALID_NUMBER_FORMAT: &'static str = lang::INVALID_NUMBER_FORMAT;
    pub const PARSE_NUMBER_FAILED: &'static str = lang::PARSE_NUMBER_FAILED;
    pub const INVALID_CHARACTER: &'static str = lang::INVALID_CHARACTER;
    pub const STRING_LENGTH_EXCEEDS_MAX: &'static str = lang::STRING_LENGTH_EXCEEDS_MAX;
    pub const MAX_NAME_SIZE_EXCEEDED: &'static str = lang::MAX_NAME_SIZE_EXCEEDED;

    // Error prefix constants (used in Display impl)
    pub const DECODING_ERROR_PREFIX: &'static str = lang::DECODING_ERROR_PREFIX;
    pub const VALIDATION_ERROR_PREFIX: &'static str = lang::VALIDATION_ERROR_PREFIX;
    pub const VERSION_ERROR_PREFIX: &'static str = lang::VERSION_ERROR_PREFIX;
    pub const MESSAGE_ERROR_PREFIX: &'static str = lang::MESSAGE_ERROR_PREFIX;
    pub const RECEIVERS_ERROR_PREFIX: &'static str = lang::RECEIVERS_ERROR_PREFIX;
    pub const NODES_ERROR_PREFIX: &'static str = lang::NODES_ERROR_PREFIX;
    pub const SIGNAL_ERROR_PREFIX: &'static str = lang::SIGNAL_ERROR_PREFIX;

    // Signal error constants
    pub const SIGNAL_PARSE_INVALID_START_BIT: &'static str = lang::SIGNAL_PARSE_INVALID_START_BIT;
    pub const SIGNAL_PARSE_INVALID_LENGTH: &'static str = lang::SIGNAL_PARSE_INVALID_LENGTH;
    pub const SIGNAL_PARSE_INVALID_FACTOR: &'static str = lang::SIGNAL_PARSE_INVALID_FACTOR;
    pub const SIGNAL_PARSE_INVALID_OFFSET: &'static str = lang::SIGNAL_PARSE_INVALID_OFFSET;
    pub const SIGNAL_PARSE_INVALID_MIN: &'static str = lang::SIGNAL_PARSE_INVALID_MIN;
    pub const SIGNAL_PARSE_INVALID_MAX: &'static str = lang::SIGNAL_PARSE_INVALID_MAX;
    pub const SIGNAL_PARSE_UNIT_TOO_LONG: &'static str = lang::SIGNAL_PARSE_UNIT_TOO_LONG;
    pub const SIGNAL_NAME_EMPTY: &'static str = lang::SIGNAL_NAME_EMPTY;
    pub const SIGNAL_LENGTH_TOO_SMALL: &'static str = lang::SIGNAL_LENGTH_TOO_SMALL;
    pub const SIGNAL_LENGTH_TOO_LARGE: &'static str = lang::SIGNAL_LENGTH_TOO_LARGE;
    #[cfg(feature = "std")]
    pub const SIGNAL_LENGTH_REQUIRED: &'static str = lang::SIGNAL_LENGTH_REQUIRED;
    #[cfg(feature = "std")]
    pub const SIGNAL_START_BIT_REQUIRED: &'static str = lang::SIGNAL_START_BIT_REQUIRED;
    #[cfg(feature = "std")]
    pub const SIGNAL_BYTE_ORDER_REQUIRED: &'static str = lang::SIGNAL_BYTE_ORDER_REQUIRED;
    #[cfg(feature = "std")]
    pub const SIGNAL_UNSIGNED_REQUIRED: &'static str = lang::SIGNAL_UNSIGNED_REQUIRED;
    #[cfg(feature = "std")]
    pub const SIGNAL_FACTOR_REQUIRED: &'static str = lang::SIGNAL_FACTOR_REQUIRED;
    #[cfg(feature = "std")]
    pub const SIGNAL_OFFSET_REQUIRED: &'static str = lang::SIGNAL_OFFSET_REQUIRED;
    #[cfg(feature = "std")]
    pub const SIGNAL_MIN_REQUIRED: &'static str = lang::SIGNAL_MIN_REQUIRED;
    #[cfg(feature = "std")]
    pub const SIGNAL_MAX_REQUIRED: &'static str = lang::SIGNAL_MAX_REQUIRED;
    pub const SIGNAL_OVERLAP: &'static str = lang::SIGNAL_OVERLAP;
    pub const SIGNAL_EXTENDS_BEYOND_MESSAGE: &'static str = lang::SIGNAL_EXTENDS_BEYOND_MESSAGE;
    pub const SIGNAL_EXTENDS_BEYOND_DATA: &'static str = lang::SIGNAL_EXTENDS_BEYOND_DATA;
    pub const SIGNAL_RECEIVERS_TOO_MANY: &'static str = lang::SIGNAL_RECEIVERS_TOO_MANY;

    // Validation and decoding error constants
    pub const NODES_DUPLICATE_NAME: &'static str = lang::NODES_DUPLICATE_NAME;
    pub const NODES_TOO_MANY: &'static str = lang::NODES_TOO_MANY;
    pub const DUPLICATE_MESSAGE_ID: &'static str = lang::DUPLICATE_MESSAGE_ID;
    pub const SENDER_NOT_IN_NODES: &'static str = lang::SENDER_NOT_IN_NODES;
    pub const INVALID_RANGE: &'static str = lang::INVALID_RANGE;
    pub const MESSAGE_TOO_MANY_SIGNALS: &'static str = lang::MESSAGE_TOO_MANY_SIGNALS;
    pub const EXTENDED_MULTIPLEXING_TOO_MANY: &'static str = lang::EXTENDED_MULTIPLEXING_TOO_MANY;
    pub const MESSAGE_NAME_EMPTY: &'static str = lang::MESSAGE_NAME_EMPTY;
    pub const MESSAGE_SENDER_EMPTY: &'static str = lang::MESSAGE_SENDER_EMPTY;
    pub const MESSAGE_DLC_TOO_SMALL: &'static str = lang::MESSAGE_DLC_TOO_SMALL;
    pub const MESSAGE_DLC_TOO_LARGE: &'static str = lang::MESSAGE_DLC_TOO_LARGE;
    #[cfg(feature = "std")]
    pub const MESSAGE_DLC_REQUIRED: &'static str = lang::MESSAGE_DLC_REQUIRED;
    pub const MESSAGE_ID_OUT_OF_RANGE: &'static str = lang::MESSAGE_ID_OUT_OF_RANGE;
    #[cfg(feature = "std")]
    pub const MESSAGE_ID_REQUIRED: &'static str = lang::MESSAGE_ID_REQUIRED;
    pub const MESSAGE_INVALID_ID: &'static str = lang::MESSAGE_INVALID_ID;
    pub const MESSAGE_INVALID_DLC: &'static str = lang::MESSAGE_INVALID_DLC;
    pub const MESSAGE_NOT_FOUND: &'static str = lang::MESSAGE_NOT_FOUND;
    pub const PAYLOAD_LENGTH_MISMATCH: &'static str = lang::PAYLOAD_LENGTH_MISMATCH;
    pub const MULTIPLEXER_SWITCH_NEGATIVE: &'static str = lang::MULTIPLEXER_SWITCH_NEGATIVE;
    #[cfg(feature = "std")]
    pub const RECEIVERS_DUPLICATE_NAME: &'static str = lang::RECEIVERS_DUPLICATE_NAME;

    // Value description error constants (no_std)
    pub const VALUE_DESCRIPTION_MESSAGE_NOT_FOUND: &'static str =
        lang::VALUE_DESCRIPTION_MESSAGE_NOT_FOUND;
    pub const VALUE_DESCRIPTION_SIGNAL_NOT_FOUND: &'static str =
        lang::VALUE_DESCRIPTION_SIGNAL_NOT_FOUND;
    pub const VALUE_DESCRIPTIONS_TOO_MANY: &'static str = lang::VALUE_DESCRIPTIONS_TOO_MANY;
    pub const VALUE_DESCRIPTIONS_EMPTY: &'static str = lang::VALUE_DESCRIPTIONS_EMPTY;

    // Extended multiplexing error constants (no_std)
    pub const EXT_MUX_MESSAGE_NOT_FOUND: &'static str = lang::EXT_MUX_MESSAGE_NOT_FOUND;
    pub const EXT_MUX_SIGNAL_NOT_FOUND: &'static str = lang::EXT_MUX_SIGNAL_NOT_FOUND;
    pub const EXT_MUX_SWITCH_NOT_FOUND: &'static str = lang::EXT_MUX_SWITCH_NOT_FOUND;
    pub const EXT_MUX_INVALID_RANGE: &'static str = lang::EXT_MUX_INVALID_RANGE;

    // Encoding error constants (no_std)
    pub const ENCODING_ERROR_PREFIX: &'static str = lang::ENCODING_ERROR_PREFIX;
    pub const ENCODING_SIGNAL_NOT_FOUND: &'static str = lang::ENCODING_SIGNAL_NOT_FOUND;
    pub const ENCODING_VALUE_OUT_OF_RANGE: &'static str = lang::ENCODING_VALUE_OUT_OF_RANGE;
    pub const ENCODING_VALUE_OVERFLOW: &'static str = lang::ENCODING_VALUE_OVERFLOW;

    // Attribute error constants (no_std)
    pub const ATTRIBUTE_DEFINITIONS_TOO_MANY: &'static str = lang::ATTRIBUTE_DEFINITIONS_TOO_MANY;
    pub const ATTRIBUTE_VALUES_TOO_MANY: &'static str = lang::ATTRIBUTE_VALUES_TOO_MANY;
    pub const ATTRIBUTE_ENUM_VALUES_TOO_MANY: &'static str = lang::ATTRIBUTE_ENUM_VALUES_TOO_MANY;
    pub const ATTRIBUTE_DEFINITION_NOT_FOUND: &'static str = lang::ATTRIBUTE_DEFINITION_NOT_FOUND;
    pub const ATTRIBUTE_VALUE_TYPE_MISMATCH: &'static str = lang::ATTRIBUTE_VALUE_TYPE_MISMATCH;
    pub const ATTRIBUTE_VALUE_OUT_OF_RANGE: &'static str = lang::ATTRIBUTE_VALUE_OUT_OF_RANGE;
    pub const ATTRIBUTE_ENUM_VALUE_INVALID: &'static str = lang::ATTRIBUTE_ENUM_VALUE_INVALID;

    // Attribute error constants (std-only)
    #[cfg(feature = "std")]
    pub const ATTRIBUTE_NAME_REQUIRED: &'static str = lang::ATTRIBUTE_NAME_REQUIRED;
    #[cfg(feature = "std")]
    pub const ATTRIBUTE_VALUE_TYPE_REQUIRED: &'static str = lang::ATTRIBUTE_VALUE_TYPE_REQUIRED;
}

/// Result type alias for operations that can return an `Error`.
pub type Result<T> = core::result::Result<T, Error>;