ahtml_html 0.1.0

A metainfo database for HTML abstractions
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
130
131
132
133
134
135
136
137
138
139
140
141
142

// FUTURE: figure out how to inherit from `From` (and keep all the
// existing From definitions for KString). It doesn't work out of the
// box (various errors).
pub trait MyFrom<T> {
    fn myfrom(s: T) -> Self;    
}

use std::borrow::Cow;

use kstring::KString;

// Can't do KString::from_static: no way to have a separate trait impl
// for &'static.
impl MyFrom<&str> for KString {
    fn myfrom(s: &str) -> Self {
        KString::from_ref(s)
    }
}

impl MyFrom<&&str> for KString {
    fn myfrom(s: &&str) -> Self {
        KString::from_ref(*s)
    }
}

impl MyFrom<&String> for KString {
    fn myfrom(s: &String) -> Self {
        KString::from_ref(s)
    }
}

impl MyFrom<String> for KString {
    fn myfrom(s: String) -> Self {
        KString::from_string(s)
    }
}

impl MyFrom<&KString> for KString {
    fn myfrom(s: &KString) -> Self {
        s.clone()
    }
}

impl MyFrom<KString> for KString {
    fn myfrom(s: KString) -> Self {
        s
    }
}

impl<'t> MyFrom<Cow<'t, str>> for KString {
    fn myfrom(s: Cow<'t, str>) -> Self {
        KString::from_ref(s.as_ref())
    }
}

impl MyFrom<usize> for KString {
    fn myfrom(val: usize) -> Self {
        // exact size needed ?
        // let mut buf: [u8; 32] = Default::default();
        // let outp: &mut [u8] = &mut buf;
        // let n = write!(outp, "{}", val).expect("enough space for the formatted number");
        KString::from_string(val.to_string())
    }
}

// impl<'t> MyFrom<HtmlString> for KString {
//     fn myfrom(s: HtmlString) -> Self {
//         let s2 = String::from_utf8(*s)?;
//         KString::from_string(s2)
//     }
// }
// Ah, cannot have errors here. So, do the conversion manually
// outside, please.



// ------------------------------------------------------------------

// / MyFrom must remain owned. Or chaining with MyAsStr as input type
// / leads to non-owned output types combined with owned input
// / types. (Does Rust never want From to lead to non-owned types,
// / BTW?)  So we extend the trait here and add them if not chained
// / with MyAsStr or similar.

// pub trait MyFromInclStr<T> : MyFrom<T> {
//     fn myfrom(s: T) -> Self;    
// }


// impl<'s> MyFromInclStr<&'s str> for &'s str {
//     fn myfrom(s: &'s str) -> Self {
//         s
//     }
// }

// impl<'s> MyFromInclStr<&&'s str> for &'s str {
//     fn myfrom(s: &&'s str) -> Self {
//         *s
//     }
// }

// impl<'s> MyFromInclStr<&'s String> for &'s str {
//     fn myfrom(s: &'s String) -> Self {
//         s
//     }
// }

// impl<'s> MyFromInclStr<&'s KString> for &'s str {
//     fn myfrom(s: &'s KString) -> Self {
//         s
//     }
// }



// Damn. IS THIS WORKABLE now  just deal with no owned inputs?:
// TODO: proper solution.

impl<'s> MyFrom<&'s str> for &'s str {
    fn myfrom(s: &'s str) -> Self {
        s
    }
}

impl<'s> MyFrom<&&'s str> for &'s str {
    fn myfrom(s: &&'s str) -> Self {
        *s
    }
}

impl<'s> MyFrom<&'s String> for &'s str {
    fn myfrom(s: &'s String) -> Self {
        s
    }
}

impl<'s> MyFrom<&'s KString> for &'s str {
    fn myfrom(s: &'s KString) -> Self {
        s
    }
}