iguazu 0.0.1

Tools for viewing, storing, and sharing mixed-signal time series data
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

use ecow::EcoString;
use strum::{EnumString, IntoStaticStr};

use super::{Attribute, string_attribute};
use crate::schema::{AttributeMap, Entity, Field, FieldKind, attribute::AttributeValue};

pub const DISPLAY: Attribute<Display> = Attribute::named("display:default");
pub const ACCENT_COLOR: Attribute<AccentColor> = Attribute::named("display:accent_color");
pub const TIMELINE_ROW: Attribute<TimelineRow> = Attribute::named("display:timeline_row");

#[derive(Copy, Clone, PartialEq, Debug, IntoStaticStr, EnumString)]
#[strum(serialize_all = "snake_case")]
pub enum Display {
    Timeline,
    Table,
}

impl<'a> TryFrom<&'a AttributeValue> for Display {
    type Error = ();

    fn try_from(value: &'a AttributeValue) -> Result<Self, Self::Error> {
        let m: AttributeMap = value.try_into().map_err(|_| ())?;
        match m.get("view").ok_or(())? {
            "timeline" => Ok(Display::Timeline),
            "table" => Ok(Display::Table),
            _ => Err(()),
        }
    }
}

impl From<Display> for AttributeValue {
    fn from(value: Display) -> Self {
        let mut m = AttributeMap::from_iter([]);
        let view_str = match value {
            Display::Timeline => "timeline",
            Display::Table => "table",
        };
        m.insert("view", EcoString::from(view_str));
        AttributeValue::from(m)
    }
}


#[derive(Copy, Clone, PartialEq, Debug, IntoStaticStr, EnumString)]
#[strum(serialize_all = "snake_case")]
pub enum AccentColor {
    Red,
    Orange,
    Brown,
    Yellow,
    Green,
    Blue,
    Purple,
}

string_attribute!(AccentColor);

#[derive(Copy, Clone, PartialEq, Debug, IntoStaticStr, EnumString)]
#[strum(serialize_all = "snake_case")]
pub enum TimelineRow {
    Hidden,

    /// Children are displayed as separate timeline rows.
    Group,

    /// Analog Y axis. If applied to an entity with children,
    /// the children are plotted on the same Y axis.
    YAxis,

    /// A row showing changes in the value, displayed as text
    Trace,

    /// Bits are shown as logic traces
    Logic,

    /// Each value is displayed as a discrete event
    Events,
}
string_attribute!(TimelineRow);

impl<D, S> Entity<D, S> {
    pub fn display_default(&self) -> Option<Display> {
        self.attribute(DISPLAY)
            .or(if self.time().is_some() || self.sample_rate().is_some() {
                Some(Display::Timeline)
            } else if matches!(self, Entity::Record { .. }) {
                Some(Display::Table)
            } else {
                None
            })
    }

    pub fn accent_color(&self) -> Option<AccentColor> {
        self.attribute(ACCENT_COLOR)
    }

    pub fn timeline_row(&self) -> TimelineRow {
        self.attribute(TIMELINE_ROW).unwrap_or_else(|| match self {
            Entity::Record { .. } if self.time().is_some() => TimelineRow::Events,
            Entity::Group { .. } | Entity::Record { .. } => TimelineRow::Group,
            Entity::Data { field, .. } => field.timeline_row(),
            _ => TimelineRow::Hidden,
        })
    }
}

impl Field {
    pub fn accent_color(&self) -> Option<AccentColor> {
        self.attribute(ACCENT_COLOR)
    }

    pub fn timeline_row(&self) -> TimelineRow {
        self.attribute(TIMELINE_ROW)
            .unwrap_or_else(|| match &self.kind {
                FieldKind::Null => TimelineRow::Hidden,
                FieldKind::BitStruct { .. } => TimelineRow::Group,
                FieldKind::Bits { bits: 1 } => TimelineRow::Logic,
                FieldKind::Bits { .. }
                | FieldKind::Character
                | FieldKind::Enum { .. }
                | FieldKind::Tagged { .. } => TimelineRow::Trace,
                FieldKind::Timestamp => TimelineRow::Hidden,
                FieldKind::Int { .. }
                | FieldKind::Signed { .. }
                | FieldKind::Float32
                | FieldKind::Float64 => TimelineRow::YAxis,
            })
    }
}