strung 0.1.4

Easy access of struct fields in strings using different/custom pre/postfix: "Hello, {field}"
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
143
144
145
146
147
148

#![allow(non_snake_case,dead_code)]
use strung::prelude::*; // import everything from prelude
 
// named struct
#[derive(Strung)]   // easy derive
struct Test {
    num: u32,
    name: &'static str,
}
 
// tuple struct
#[derive(Strung)]   // easy derive
struct TestTup(u32,&'static str);                 
 
// custom pre/postfix per struct + ignore
#[derive(Strung)]   // easy derive
#[strung("%","%")]  // custom pre/postfix!
struct TestCustom {
    num: u32,
    // ignore: makes this field unavailable
    // this would fail w/o the ignore, cause no [Display]!
    // other usage: gain a lil more performance
    #[strung(ignore)] nop: NoDsply  
}
 
// custom pre/postfix per struct + ignore
#[derive(Strung)]   // easy derive
struct TestCascade {
    // cascade: makes the fields of another Strung available
    // the ignore only affects the the struct itself, not its fields
    // and this would fail w/o it cause it doesn't implement it!
    #[strung(cascade)]
     tup: TestTup  
}
 
// struct with no Display trait
struct NoDsply;

fn main(){
 
    // create structs!
    let NAMED  = Test {num: 1, name: "st"};
    let TUPLE  = TestTup (1, "st");
    let CUSTOM = TestCustom {num: 1, nop: NoDsply};
 
    // most general - you'll probably mostly use this! - using {field_name}
    let text = NAMED.strung("{num}{name}"); 
    println!("strung: {}",&text);
     
    // also works with String, just reference it
    let s: String = "{num}{name}".into();
    let text = NAMED.strung(&s); 
    println!("strung with String: {}",&text);
 
    // it will always replace every occurrence
    let text = NAMED.strung("{num}{num}th < {num}{name}"); 
    println!("strung multi: {}",&text);
 
    // for tuple structs, use the fields index number, instead of the name
    let text = TUPLE.strung("{0}{1}"); 
    println!("strung tuple: {}",&text);
     
    // the [strung] function will change if you set custom pre/postfix - see TestCustom above
    let text = CUSTOM.strung("%num%st"); 
    println!("strung custom per struct: {}",&text);
 
    // there are different presets, so you can still use {field_name} using [strung_curly]
    let text = CUSTOM.strung_curly("{num}st"); 
    println!("strung_curly: {}",&text);
 
    // note: {nop} is not available, cause it's ignored - see TestCustom above
    let text = CUSTOM.strung_curly("{num}st {nop}"); 
    println!("strung ignored: {}",&text);
 
    // [strung_dollar] for $field_name
    let text = NAMED.strung_dollar("$num$name");
    println!("strung_dollar: {}",&text);
 
    // [strung_dollry] for ${field_name}
    let text = NAMED.strung_dollry("${num}${name}");
    println!("strung_dollry: {}",&text);
 
    // [strung_hashtag] for #field_name
    let text = NAMED.strung_hashtag("#num#name");
    println!("strung_hashtag: {}",&text);
 
    // most flexible - inline setting via [strung_dynamic] - a bit less efficient
    let text = NAMED.strung_dynamic("<",">","<num><name>");
    println!("strung_dynamic: {}",&text);
 
    // also flexible - global static variables, you can easily change ...
    strung::set_static("+","+");
    let text = NAMED.strung_static("+num++name+");
    println!("strung_static[1]: {}",&text);
 
    // ... whenever you want, but usually you'll just need it once at the start of the main
    strung::set_static("[","]");
    let text = NAMED.strung_static("[num][name]");
    println!("strung_static[2]: {}",&text);
 
    // [strung_hashtag] and [strung_dollar] also enable cascading
    let CASCADE = TestCascade {tup: TestTup(2,"nd")};
    let text = CASCADE.strung_dollar("$tup.0$tup.1");
    println!("strung_dollar cascading: {}",&text);
 
    // [strung_hashtag] and [strung_dollar] also enable cascading
    let CASCADE = TestCascade {tup: TestTup(2,"nd")};
    let text = CASCADE.strung_hashtag("#tup.0#tup.1");
    println!("strung_hashtag cascading: {}",&text);

    // [strung_hashtag] and [strung_dollar] also enable cascading
    let CASCADE = TestCascade {tup: TestTup(2,"nd")};
    let text = CASCADE.strung_curly("{tup.0}{tup.1}");
    println!("strung_curly cascading: {}",&text);

    // [strung_hashtag] and [strung_dollar] also enable cascading
    let CASCADE = TestCascade {tup: TestTup(2,"nd")};
    let text = CASCADE.strung_angle("<tup.0><tup.1>");
    println!("strung_angle cascading: {}",&text);
    
    // [strung_hashtag] and [strung_dollar] also enable cascading
    let CASCADE = TestCascade {tup: TestTup(2,"nd")};
    let text = CASCADE.strung_dollry("${0.0}${tup.1}");
    println!("strung_dollry cascading: {}",&text);
    
    // [strung_hashtag] and [strung_dollar] also enable cascading
    let CASCADE = TestCascade {tup: TestTup(2,"nd")};
    let text = CASCADE.strung("{tup.0}{tup.1}");
    println!("strung cascading: {}",&text);
 
    // most flexible - inline setting via [strung_dynamic] - a bit less efficient
    let text = CASCADE.strung_dynamic("<",">","<tup.0><tup.1>");
    println!("strung_dynamic cascading: {}",&text);

    // also flexible - global static variables, you can easily change ...
    strung::set_static("+","+");
    let text = CASCADE.strung_static("+0.0++0.1+");
    println!("strung_static cascading: {}",&text);

    // most flexible - using generic const chars
    let text = NAMED.strung_generic::<'<','>'>("<num><name>");
    println!("strung_generic: {}",&text);

    // most flexible - using generic const chars
    let text = CASCADE.strung_generic::<'<','>'>("<tup.0><tup.1>");
    println!("strung_generic cascading: {}",&text);

}