defmt_decoder

https://docs.rs/defmt-decoder/1.0.0/defmt_decoder/
Admin
Decodes `defmt` log frames on the host, converting them into human-readable log messages (as...
Tokens:3,787
Snippets:43
Trust Score:9.7
Update:1 year ago
Show doc for...
Tokens:
Raw
### Get FormatterFormat Options (Rust)

Source: https://docs.rs/defmt-decoder/1.0.0/defmt_decoder/log/format/enum

Retrieves an iterator yielding valid string names for the `FormatterFormat` options. This function excludes `FormatterFormat::Custom` as it requires a format string argument.

```Rust
pub fn get_options() -> impl Iterator<Item = &'static str>
```

--------------------------------

### Initialize defmt logger

Source: https://docs.rs/defmt-decoder/1.0.0/defmt_decoder/log/index

Initializes a log sink that specifically handles defmt frames. This function sets up the necessary components to process defmt-formatted logs within the Rust ecosystem.

```rust
pub fn init_logger() -> DefmtLoggerConfig
```

--------------------------------

### Create New TableEntry in Rust

Source: https://docs.rs/defmt-decoder/1.0.0/defmt_decoder/struct

Provides a constructor function `new` for the `TableEntry` struct. This function takes a `StringEntry` and a `String` representing the raw symbol to create a new `TableEntry` instance.

```Rust
pub fn new(string: StringEntry, raw_symbol: String) -> Self
```

--------------------------------

### Define DefmtLoggerConfig Structure

Source: https://docs.rs/defmt-decoder/1.0.0/defmt_decoder/log/struct

Defines the DefmtLoggerConfig struct which holds configuration settings for the defmt logger. It includes fields for a formatter, host formatter, and logger type. This struct is fundamental for setting up logging behavior.

```rust
pub struct DefmtLoggerConfig {
    pub formatter: Formatter,
    pub host_formatter: HostFormatter,
    pub logger_type: DefmtLoggerType,
}
```

--------------------------------

### Log a defmt frame

Source: https://docs.rs/defmt-decoder/1.0.0/defmt_decoder/log/index

Logs a defmt frame using the Rust log facade. This function allows defmt-encoded messages to be processed and outputted through the standard logging infrastructure.

```rust
pub fn log_defmt(record: &Record<'_>) -> Result<(), log::SetLoggerError>
```

--------------------------------

### Create Custom Formatter Config - Rust

Source: https://docs.rs/defmt-decoder/1.0.0/defmt_decoder/log/format/struct

Provides a constructor for `FormatterConfig` to create a custom formatter. This allows users to specify a custom log-format string, offering flexibility in how log output is presented. Refer to the defmt book for details on format string syntax.

```rust
pub fn custom(format: &'a str) -> Self
```

--------------------------------

### Rust From Trait Implementation for Tag

Source: https://docs.rs/defmt-decoder/1.0.0/defmt_decoder/enum

Demonstrates the blanket implementation of the `From<T>` trait for `T` itself, which simply returns the argument unchanged. This is a common auto-trait implementation.

```rust
impl<T> From<T> for T {
    fn from(t: T) -> T
}
```

--------------------------------

### Implement PartialEq Trait for TableEntry in Rust

Source: https://docs.rs/defmt-decoder/1.0.0/defmt_decoder/struct

Implements the `PartialEq` trait for the `TableEntry` struct, enabling comparison of `TableEntry` instances for equality. This includes methods for both equality (`eq`) and inequality (`ne`).

```Rust
fn eq(&self, other: &TableEntry) -> bool
```

```Rust
fn ne(&self, other: &Rhs) -> bool
```

--------------------------------

### Rust PartialEq Trait Implementation for Tag

Source: https://docs.rs/defmt-decoder/1.0.0/defmt_decoder/enum

Illustrates the implementation of the `PartialEq` trait for the `Tag` enum, allowing for equality comparisons between `Tag` variants.

```rust
impl PartialEq for Tag {
    fn eq(&self, other: &Tag) -> bool
    fn ne(&self, other: &Rhs) -> bool
}
```

--------------------------------

### Rust TryInto Trait Implementation for Tag

Source: https://docs.rs/defmt-decoder/1.0.0/defmt_decoder/enum

Demonstrates the blanket implementation of the `TryInto<U>` trait for `T` where `U` implements `TryFrom<T>`. This enables fallible conversions from `T` to `U` using `try_into()`.

```rust
impl<T, U>
TryInto<U> for T
where
    U: TryFrom<T>,
{
    type Error = <U as TryFrom<T>>::Error;
    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>
}
```

--------------------------------

### Implement TryInto Trait for Generic Types in Rust

Source: https://docs.rs/defmt-decoder/1.0.0/defmt_decoder/struct

Shows the implementation of the `TryInto` trait for generic types `T` and `U`. This provides a convenient way to attempt a conversion from `T` to `U`, returning a `Result`.

```Rust
type Error = <U as TryFrom<T>>::Error

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>
```

--------------------------------

### Default FormatterConfig Implementation - Rust

Source: https://docs.rs/defmt-decoder/1.0.0/defmt_decoder/log/format/struct

Implements the `Default` trait for `FormatterConfig`, providing a default configuration. This allows for easy instantiation of a `FormatterConfig` with standard settings when no specific customization is immediately required.

```rust
fn default() -> FormatterConfig<'a>
```

--------------------------------

### Implement Debug Trait for TableEntry in Rust

Source: https://docs.rs/defmt-decoder/1.0.0/defmt_decoder/struct

Implements the `Debug` trait for the `TableEntry` struct, allowing instances of `TableEntry` to be formatted for debugging purposes. This involves defining the `fmt` method.

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

--------------------------------

### Rust TryFrom Trait Implementation for Tag

Source: https://docs.rs/defmt-decoder/1.0.0/defmt_decoder/enum

Illustrates the blanket implementation of the `TryFrom<U>` trait for `T` where `U` implements `Into<T>`. This allows for fallible conversions from `U` to `T` using `try_from()`.

```rust
impl<T, U>
TryFrom<U> for T
where
    U: Into<T>,
{
    type Error = Infallible;
    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>
}
```

--------------------------------

### Parse String to FormatterFormat (Rust)

Source: https://docs.rs/defmt-decoder/1.0.0/defmt_decoder/log/format/enum

Provides a function to parse a string into a `FormatterFormat` variant. It takes the string to parse and a boolean indicating whether to include location information. Unknown strings will result in `None`.

```Rust
pub fn from_string( s: &str, with_location: bool, ) -> Option<FormatterFormat<'static>>
```

--------------------------------

### Implement TryFrom Trait for Generic Type U to T

Source: https://docs.rs/defmt-decoder/1.0.0/defmt_decoder/log/struct

This code demonstrates the blanket implementation of the `TryFrom` trait, allowing a type `U` to be attempted to be converted into type `T`, where `U: Into<T>`. It returns a `Result` to handle potential conversion errors.

```rust
impl<T, U> TryFrom<U> for T
where U: Into<T>
```

--------------------------------

### Rust Into Trait Implementation for Tag

Source: https://docs.rs/defmt-decoder/1.0.0/defmt_decoder/enum

Shows the blanket implementation of the `Into<U>` trait for `T` where `U` implements `From<T>`. This enables conversion from `T` to `U` via the `into()` method.

```rust
impl<T, U> Into<U> for T
where
    U: From<T>,
{
    fn into(self) -> U
}
```

--------------------------------

### Implement TryInto Trait for Generic Type T to U

Source: https://docs.rs/defmt-decoder/1.0.0/defmt_decoder/log/struct

This snippet shows the blanket implementation of the `TryInto` trait, enabling a type `T` to be attempted to be converted into type `U`, provided `U: TryFrom<T>`. It returns a `Result` to handle potential conversion errors.

```rust
impl<T, U> TryInto<U> for T
where U: TryFrom<T>
```

--------------------------------

### Rust Debug Trait Implementation for Tag

Source: https://docs.rs/defmt-decoder/1.0.0/defmt_decoder/enum

Shows the implementation of the `Debug` trait for the `Tag` enum, enabling formatted output of `Tag` variants for debugging purposes.

```rust
impl Debug for Tag {
    fn fmt(&self, f: &mut Formatter<'_>) -> Result
}
```

--------------------------------

### Implement Sync Trait for DefmtLoggerConfig

Source: https://docs.rs/defmt-decoder/1.0.0/defmt_decoder/log/struct

This snippet shows the implementation of the `Sync` trait for `DefmtLoggerConfig`. The `Sync` trait indicates that a type can be safely shared (referenced) across multiple threads concurrently.

```rust
impl Sync for DefmtLoggerConfig
```

--------------------------------

### Define FormatterConfig Struct - Rust

Source: https://docs.rs/defmt-decoder/1.0.0/defmt_decoder/log/format/struct

Defines the `FormatterConfig` struct used to control how defmt frames are formatted. It includes fields for the desired format and whether a timestamp is available. This struct is central to configuring the defmt decoding process.

```rust
pub struct FormatterConfig<'a> {
    pub format: FormatterFormat<'a>,
    pub is_timestamp_available: bool,
}
```

--------------------------------

### Implement Any Trait for Generic Type T

Source: https://docs.rs/defmt-decoder/1.0.0/defmt_decoder/log/struct

This code snippet shows the blanket implementation of the `Any` trait for any type `T` that is `'static` and sized. The `Any` trait allows for runtime type identification and downcasting.

```rust
impl<T> Any for T
where T: 'static + ?Sized
```

--------------------------------

### Implement Send Trait for DefmtLoggerConfig

Source: https://docs.rs/defmt-decoder/1.0.0/defmt_decoder/log/struct

This code illustrates the implementation of the `Send` trait for `DefmtLoggerConfig`. The `Send` trait signifies that a type can be safely transferred (sent) across thread boundaries.

```rust
impl Send for DefmtLoggerConfig
```

--------------------------------

### Enable Timestamp in Formatter Config - Rust

Source: https://docs.rs/defmt-decoder/1.0.0/defmt_decoder/log/format/struct

A method to modify an existing `FormatterConfig` to indicate that timestamps should be included in the logs. This is useful when the target system can provide timestamp information.

```rust
pub fn with_timestamp(self) -> Self
```

--------------------------------

### Implement From Trait for Generic Type T

Source: https://docs.rs/defmt-decoder/1.0.0/defmt_decoder/log/struct

This code represents the blanket implementation of the `From` trait for any type `T`. The `From<T>` trait allows conversion from type `T` into another type `U` by calling `U::from(t)`.

```rust
impl<T> From<T> for T
```

--------------------------------

### Implement TryFrom Trait for Generic Types in Rust

Source: https://docs.rs/defmt-decoder/1.0.0/defmt_decoder/struct

Demonstrates the implementation of the `TryFrom` trait for generic types `T` and `U`. This allows attempting to convert a value of type `U` into a value of type `T`, returning a `Result`.

```Rust
type Error = Infallible

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>
```

--------------------------------

### Implement RefUnwindSafe Trait for DefmtLoggerConfig

Source: https://docs.rs/defmt-decoder/1.0.0/defmt_decoder/log/struct

This snippet shows the implementation of the `RefUnwindSafe` trait for `DefmtLoggerConfig`. This trait indicates that a type is safe to unwind through when references are involved, crucial for exception handling in Rust.

```rust
impl RefUnwindSafe for DefmtLoggerConfig
```

--------------------------------

### Implement Unpin Trait for DefmtLoggerConfig

Source: https://docs.rs/defmt-decoder/1.0.0/defmt_decoder/log/struct

This code demonstrates the implementation of the `Unpin` trait for `DefmtLoggerConfig`. The `Unpin` trait is a marker trait indicating that a type's pinned state does not need to be changed when moved, which is important for self-referential structs and certain async operations.

```rust
impl Unpin for DefmtLoggerConfig
```

--------------------------------

### Check for defmt frame

Source: https://docs.rs/defmt-decoder/1.0.0/defmt_decoder/log/index

Determines if the provided metadata belongs to a log record that was produced by the `log_defmt` function. This is useful for filtering or identifying specific types of log entries.

```rust
pub fn is_defmt_frame(metadata: &Record<'_>) -> bool
```

--------------------------------

### StreamDecoder Trait

Source: https://docs.rs/defmt-decoder/1.0.0/defmt_decoder/trait

The StreamDecoder trait defines the interface for decoding defmt data. It requires implementations for receiving data and decoding frames.

```APIDOC
## Trait StreamDecoder

### Description
The `StreamDecoder` trait provides an interface for processing a stream of bytes and decoding them into `Frame` objects.

### Methods

#### fn received(&mut self, data: &[u8])

##### Description
Pushes received data into the decoder. The decoder stores this data internally and makes decoded frames available via the `decode` method.

##### Parameters
* **data** (&[u8]) - Required - A slice of bytes representing the received data.

#### fn decode(&mut self) -> Result<Frame<'_>, DecodeError>

##### Description
Attempts to decode a `Frame` from the internally stored data. Returns `Ok(Frame)` on success or `Err(DecodeError)` if decoding fails or no complete frame is available.

##### Response
* **Success Response (Ok)** - Contains the decoded `Frame`.
* **Error Response (Err)** - Contains a `DecodeError` indicating why decoding failed.
```

--------------------------------

### Enable Location in Formatter Config - Rust

Source: https://docs.rs/defmt-decoder/1.0.0/defmt_decoder/log/format/struct

A method to modify a `FormatterConfig` to include location information in the logs. It's advised not to use this feature with custom log formatters to avoid potential conflicts or unexpected output.

```rust
pub fn with_location(self) -> Self
```

--------------------------------

### Implement Freeze Trait for DefmtLoggerConfig

Source: https://docs.rs/defmt-decoder/1.0.0/defmt_decoder/log/struct

This code snippet demonstrates the implementation of the `Freeze` trait for the `DefmtLoggerConfig` struct. The `Freeze` trait is typically used in Rust for types that can be safely frozen (made immutable) across threads.

```rust
impl Freeze for DefmtLoggerConfig
```

--------------------------------

### Implement Into Trait for Generic Type T to U

Source: https://docs.rs/defmt-decoder/1.0.0/defmt_decoder/log/struct

This snippet shows the blanket implementation of the `Into` trait for a generic type `T` that can be converted into type `U`, provided `U: From<T>`. This enables calling `self.into()` for conversions.

```rust
impl<T, U> Into<U> for T
where U: From<T>
```

--------------------------------

### Implement Borrow Trait for Generic Type T

Source: https://docs.rs/defmt-decoder/1.0.0/defmt_decoder/log/struct

This code demonstrates the blanket implementation of the `Borrow` trait for any type `T`. The `Borrow` trait allows a type `T` to be borrowed as a reference to another type `U` (where `T: Borrow<U>`), facilitating immutable access.

```rust
impl<T> Borrow<T> for T
where T: ?Sized
```

--------------------------------

### Rust Enum Tag Definition

Source: https://docs.rs/defmt-decoder/1.0.0/defmt_decoder/enum

Defines the `Tag` enum, which specifies the origin of a format string used in the defmt logging framework. It enumerates various sources like primitive types, derived macros, and user-defined strings.

```rust
pub enum Tag {
    Prim,
    Derived,
    Bitflags,
    Write,
    Str,
    Timestamp,
    BitflagsValue,
    Println,
    Trace,
    Debug,
    Info,
    Warn,
    Error,
}
```

--------------------------------

### Define FormatterFormat Enum (Rust)

Source: https://docs.rs/defmt-decoder/1.0.0/defmt_decoder/log/format/enum

Defines the `FormatterFormat` enum used for customizing defmt log output. It includes variants for default two-line formatting, single-line formatting, and custom string-based formatting. The enum is marked as non-exhaustive, indicating potential future additions.

```Rust
#[non_exhaustive]
pub enum FormatterFormat<'a> {
    Default {
        with_location: bool,
    },
    OneLine {
        with_location: bool,
    },
    Custom(&'a str),
}

```

--------------------------------

### Implement UnwindSafe Trait for DefmtLoggerConfig

Source: https://docs.rs/defmt-decoder/1.0.0/defmt_decoder/log/struct

This snippet shows the implementation of the `UnwindSafe` trait for `DefmtLoggerConfig`. This trait indicates that a type is safe to unwind through during panic handling, ensuring memory safety when exceptions occur.

```rust
impl UnwindSafe for DefmtLoggerConfig
```

--------------------------------

### received Method Signature for StreamDecoder in Rust

Source: https://docs.rs/defmt-decoder/1.0.0/defmt_decoder/trait

Represents the `received` method signature within the `StreamDecoder` trait. This method is responsible for accepting and processing raw byte slices (`data`) received by the decoder. It is a core component for feeding data into the decoding process.

```Rust
fn received(&mut self, data: &[u8])
```

--------------------------------

### Define TableEntry Struct in Rust

Source: https://docs.rs/defmt-decoder/1.0.0/defmt_decoder/struct

Defines the `TableEntry` struct, which is an entry in a `Table` that combines a format string with its raw symbol. This struct has private fields and is used internally by the defmt-decoder crate.

```Rust
pub struct TableEntry { /* private fields */ }
```

--------------------------------

### decode Method Signature for StreamDecoder in Rust

Source: https://docs.rs/defmt-decoder/1.0.0/defmt_decoder/trait

Represents the `decode` method signature within the `StreamDecoder` trait. This method attempts to decode stored data into a `Frame`. It returns a `Result` which can be either a successfully decoded `Frame` or a `DecodeError` if decoding fails.

```Rust
fn decode(&mut self) -> Result<Frame<'_>, DecodeError>
```

--------------------------------

### StreamDecoder Trait Definition in Rust

Source: https://docs.rs/defmt-decoder/1.0.0/defmt_decoder/trait

Defines the `StreamDecoder` trait, which outlines the interface for receiving data and decoding frames. Implementors must provide logic for handling incoming bytes and extracting structured frames. Dependencies include `Frame` and `DecodeError` types.

```Rust
pub trait StreamDecoder {
    // Required methods
    fn received(&mut self, data: &[u8]);
    fn decode(&mut self) -> Result<Frame<'_>, DecodeError>;
}
```

--------------------------------

### Define DefmtLoggerType Enum in Rust

Source: https://docs.rs/defmt-decoder/1.0.0/defmt_decoder/log/enum

This Rust code defines an enumeration `DefmtLoggerType` which can represent two logging output types: `Stdout` or `Json`. This enum is useful for configuring the output format of the defmt decoder.

```rust
pub enum DefmtLoggerType {
    Stdout,
    Json,
}
```

--------------------------------

### Implement BorrowMut Trait for Generic Type T

Source: https://docs.rs/defmt-decoder/1.0.0/defmt_decoder/log/struct

This snippet shows the blanket implementation of the `BorrowMut` trait for any type `T`. The `BorrowMut` trait enables mutable borrowing of a type `T` as a mutable reference to another type `U` (where `T: BorrowMut<U>`).

```rust
impl<T> BorrowMut<T> for T
where T: ?Sized
```
Tokens:
Raw