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
use std::fmt;
use std::borrow::Cow;
use crate::konst2::traits::*;
use crate::ty2::{FloatingType, Type};
#[derive(Debug, Clone, PartialEq)]
pub struct FloatingConst<'t> {
ty: &'t FloatingType,
value: f64,
}
impl<'t> FloatingConst<'t> {
pub fn try_new(ty: &'t FloatingType, value: f64) -> Result<FloatingConst<'t>, ConstError> {
let valid = match ty.range() {
Some(r) => r.contains(&value),
None => true,
};
if valid {
Ok(FloatingConst {
ty: ty,
value: value,
})
} else {
Err(ConstError::OutOfRange)
}
}
pub fn floating_type(&self) -> &'t FloatingType {
self.ty
}
pub fn value(&self) -> f64 {
self.value
}
}
impl<'t> Const2<'t> for FloatingConst<'t> {
fn ty(&self) -> &'t Type {
self.ty.as_type()
}
fn as_any<'a>(&'a self) -> AnyConst<'a, 't> {
AnyConst::Floating(self)
}
fn into_owned(self) -> OwnedConst<'t> {
OwnedConst::Floating(self)
}
fn to_owned(&self) -> OwnedConst<'t> {
OwnedConst::Floating(self.clone())
}
fn cast(&self, ty: &'t Type) -> Result<Cow<Const2<'t> + 't>, ConstError> {
if self.ty.as_type() == ty {
return Ok(Cow::Borrowed(self));
}
unimplemented!("casting of float constants")
}
}
impl<'t> fmt::Display for FloatingConst<'t> {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.value)
}
}
impl<'t> Eq for FloatingConst<'t> {}