liberty-db 0.1.8

`liberty` data structre
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

use std::fmt;
use crate::types::*;
use super::{
    BooleanExpressionLike,
    LogicState,LogicVector,
    LogicTable, BooleanExpression, StaticState,
};

#[derive(Clone,Debug,Hash,PartialEq,Eq)]
#[derive(Ord)]
#[derive(PartialOrd)]
pub struct Port{
    name:  String,
}
impl Port {
    #[inline]
    pub fn new(name: &str) -> Self{
        Self { name: name.to_string() }
    }
}

impl Into<BooleanExpression> for Port{
    #[inline]
    fn into(self) -> BooleanExpression {
        BooleanExpression{
            value: Box::new(self)
        }
    }
}

impl fmt::Display for Port{
    #[inline]
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(f, "{}", self.name)
    }
}

lazy_static! {
    static ref BASIC_MAP: HashMap<LogicVector, LogicState> = LogicState::iter().map(|state| 
                                                                    (vec![state].into(),state)
                                                                ).collect();
    static ref ONE_MAP: HashMap<LogicVector, LogicState> = LogicState::iter().map(|state| 
                                                                    (vec![state].into(),LogicState::Static(StaticState::High))
                                                                ).collect();
    static ref ZERO_MAP: HashMap<LogicVector, LogicState> = LogicState::iter().map(|state| 
                                                                    (vec![state].into(),LogicState::Static(StaticState::Low))
                                                                ).collect();
}

impl BooleanExpressionLike for Port{
    #[inline]
    fn to_table(&self) -> LogicTable {
        LogicTable::new( 
            &self.name,
            BASIC_MAP.clone(),
            vec![self.clone()]
        )
    }
}

#[derive(Clone,Debug,Hash,PartialEq,Eq)]
pub struct StaticExpression{
    state:  StaticState,
}
impl StaticExpression {
    #[inline]
    pub fn new(state:  StaticState,) -> Self{
        Self { state }
    }
}

impl Into<BooleanExpression> for StaticExpression{
    #[inline]
    fn into(self) -> BooleanExpression {
        BooleanExpression{
            value: Box::new(self)
        }
    }
}

impl fmt::Display for StaticExpression{
    #[inline]
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        self.state.fmt(f)
    }
}

impl std::ops::Deref for StaticExpression {
    type Target=StaticState;

    fn deref(&self) -> &Self::Target {
        &self.state
    }
}

impl Into<StaticState> for StaticExpression {
    fn into(self) -> StaticState {
        self.state
    }
}

impl BooleanExpressionLike for StaticExpression{
    #[inline]
    fn to_table(&self) -> LogicTable {
        LogicTable::new(
            format!("{}",self.state).as_str(),
            {match self.state {
                StaticState::High => ONE_MAP.clone(),
                StaticState::Low => ZERO_MAP.clone(),
            }},
            vec![Port::new(format!("{}",self.state).as_str())],
        )
    }
}