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

crate::ix!();

//-------------------------------------------[.cpp/bitcoin/src/util/translation.h]

/**
  | Bilingual messages:
  | 
  | - in GUI: user's native language + untranslated
  | (i.e. English)
  | 
  | - in log and stderr: untranslated only
  |
  */
#[derive(Default)]
pub struct BilingualStr {
    original:   String,
    translated: String,
}

impl AddAssign<&BilingualStr> for BilingualStr {
    
    #[inline]fn add_assign(&mut self, other: &BilingualStr) {
        todo!();
        /*
            original += rhs.original;
            translated += rhs.translated;
            return *this;
        */
    }
}

impl BilingualStr {

    pub fn empty(&self) -> bool {
        
        todo!();
        /*
            return original.empty();
        */
    }
    
    pub fn clear(&mut self)  {
        
        todo!();
        /*
            original.clear();
            translated.clear();
        */
    }
}

impl Add<&BilingualStr> for BilingualStr {

    type Output = BilingualStr;
    
    fn add(self, other: &BilingualStr) -> Self::Output {
        todo!();
        /*
            lhs += rhs;
        return lhs;
        */
    }
}

impl From<&str> for BilingualStr {
    fn from(x: &str) -> Self {
        untranslated(x)
    }
}

/**
  | Mark a bilingual_str as untranslated
  |
  */
#[inline] pub fn untranslated(original: &str) -> BilingualStr {
    
    todo!();
        /*
            return {original, original};
        */
}

pub mod tinyformat {

    use super::*;

    pub fn format<Args>(
            fmt:  &BilingualStr,
            args: &Args) -> BilingualStr {

        todo!();
            /*
                return bilingual_str{format(fmt.original, args...), format(fmt.translated, args...)};
            */
    }
}

/**
  | Translate a message to the native language
  | of the user.
  |
  */
lazy_static!{
    /*
    const extern std::function<std::string(const char*)> G_TRANSLATION_FUN;
    */
}

/**
  | Translation function.
  | 
  | If no translation function is set, simply
  | return the input.
  |
  */
lazy_static!{
    /*
    inline bilingual_str _(const char* psz)
    {
        return bilingual_str{psz, G_TRANSLATION_FUN ? (G_TRANSLATION_FUN)(psz) : psz};
    }
    */
}