haystack-types 0.1.1

Haystack types and traits for Rust.
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

use crate::{HVal,HType};
use std::fmt::{self,Write,Display,Formatter};
use num::Float;
use std::str::FromStr;

#[derive(PartialEq,Debug)]
pub struct HUnit(String);

impl HUnit {
    pub fn new(unit: String) -> HUnit {
        HUnit(unit)
    }
}

#[derive(PartialEq,Debug)]
pub struct HNumber<T: Display> {
    val: T,
    unit: Option<HUnit>
}

pub type Number<T> = HNumber<T>;
pub trait NumTrait: Float + Display + FromStr {}
impl<T> NumTrait for T where T: Float + Display + FromStr {}
//impl<'a,T> NumTrait for T where T: 'a + Float + Display + FromStr {}

const THIS_TYPE: HType = HType::Number;

impl <T: Float + Display>Number<T> {
    pub fn new(num: T, unit: Option<HUnit>) -> Self {
        HNumber { val: num, unit }
    }

    pub fn val(&self) -> T {
        self.val
    }
}

impl <'a, T: NumTrait + 'a>HVal<'a,T> for HNumber<T> {
    fn to_zinc(&self, buf: &mut String) -> fmt::Result {
        match &self.unit {
            Some(unit) =>  write!(buf,"{}{}",self.val,unit),
            None => write!(buf,"{}",self.val),
        }
    }
    fn to_json(&self, buf: &mut String) -> fmt::Result {
        match &self.unit {
            Some(unit) =>  write!(buf,"{} {}",self.val,unit),
            None => write!(buf,"{}",self.val),
        }
    }
    fn haystack_type(&self) -> HType { THIS_TYPE }

    set_trait_eq_method!(get_number_val,'a,T);
    set_get_method!(get_number_val, HNumber<T>);
}

impl Display for HUnit {
    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
        write!(f, "{}", self.0)
    }
}