probe-rs-tools 0.32.0

A collection of on chip debugging tools to communicate with microchips.
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

use std::marker::PhantomData;

use serde::{Deserialize, Serialize};

use super::dap::dap_types::{Event, Request, Response};

pub mod decoder;
pub mod encoder;

pub(crate) struct DapCodec<T: Serialize + for<'a> Deserialize<'a>> {
    length: Option<usize>,
    header_received: bool,
    _pd: PhantomData<T>,
}

impl<T: Serialize + for<'a> Deserialize<'a> + PartialEq> DapCodec<T> {
    pub(crate) fn new() -> Self {
        Self {
            length: None,
            header_received: false,
            _pd: PhantomData,
        }
    }
}

#[derive(Debug, PartialEq, Serialize, Deserialize)]
pub(crate) struct Frame<T: PartialEq> {
    pub content: T,
}

impl<T: PartialEq> Frame<T> {
    pub(crate) fn new(content: T) -> Self {
        Self { content }
    }
}

#[derive(Debug, PartialEq, Serialize, Deserialize)]
#[serde(untagged)]
pub(crate) enum Message {
    Request(Request),
    Response(Response),
    Event(Event),
}

impl Message {
    pub(crate) fn kind(&self) -> MessageKind {
        match self {
            Message::Request(_) => MessageKind::Request,
            Message::Response(_) => MessageKind::Response,
            Message::Event(_) => MessageKind::Event,
        }
    }
}

#[derive(Debug, PartialEq, Serialize, Deserialize)]
pub(crate) enum MessageKind {
    Request,
    Response,
    Event,
}

impl From<Event> for Message {
    fn from(value: Event) -> Self {
        Self::Event(value)
    }
}

impl From<Response> for Message {
    fn from(value: Response) -> Self {
        Self::Response(value)
    }
}

impl From<Request> for Message {
    fn from(value: Request) -> Self {
        Self::Request(value)
    }
}