]>
Commit | Line | Data |
---|---|---|
7c673cae FG |
1 | // Copyright (c) 2009-2016 Vladimir Batov. |
2 | // Use, modification and distribution are subject to the Boost Software License, | |
3 | // Version 1.0. See http://www.boost.org/LICENSE_1_0.txt. | |
4 | ||
5 | #ifdef _MSC_VER | |
6 | # pragma warning(disable : 4127) // conditional expression is constant. | |
7 | # pragma warning(disable : 4189) // local variable is initialized but not referenced. | |
8 | # pragma warning(disable : 4100) // unreferenced formal parameter. | |
9 | # pragma warning(disable : 4714) // marked as __forceinline not inlined. | |
10 | #endif | |
11 | ||
12 | namespace { namespace local | |
13 | { | |
14 | #if defined(_MSC_VER) | |
15 | static bool const is_msc = true; | |
16 | #else | |
17 | static bool const is_msc = false; | |
18 | #endif | |
19 | }} | |
20 | ||
21 | #include <boost/bind.hpp> | |
22 | #include <boost/detail/lightweight_test.hpp> | |
23 | ||
24 | static | |
25 | void | |
26 | log(char const*) | |
27 | { | |
28 | // Dummy function to demonstrate how problems might be logged. | |
29 | } | |
30 | ||
31 | //[getting_started_headers1 | |
32 | #include <boost/convert.hpp> | |
33 | #include <boost/convert/lexical_cast.hpp> | |
34 | //] | |
35 | ||
36 | //[getting_started_using | |
37 | using std::string; | |
38 | using boost::lexical_cast; | |
39 | using boost::convert; | |
40 | //] | |
41 | //[getting_started_default_converter | |
42 | // Definition of the default converter (optional) | |
b32b8144 | 43 | struct boost::cnv::by_default : boost::cnv::lexical_cast {}; |
7c673cae FG |
44 | //] |
45 | ||
46 | static | |
47 | void | |
48 | getting_started_example1() | |
49 | { | |
50 | //[getting_started_example1 | |
51 | try | |
52 | { | |
53 | boost::cnv::lexical_cast cnv; // boost::lexical_cast-based converter | |
54 | ||
55 | int i1 = lexical_cast<int>("123"); // boost::lexical_cast standard deployment | |
56 | int i2 = convert<int>("123").value(); // boost::convert with the default converter | |
57 | int i3 = convert<int>("123", cnv).value(); // boost::convert with an explicit converter | |
58 | string s1 = lexical_cast<string>(123); // boost::lexical_cast standard deployment | |
59 | string s2 = convert<string>(123).value(); // boost::convert with the default converter | |
60 | string s3 = convert<string>(123, cnv).value(); // boost::convert with an explicit converter | |
61 | ||
62 | BOOST_TEST(i1 == 123); | |
63 | BOOST_TEST(i2 == 123); | |
64 | BOOST_TEST(i3 == 123); | |
65 | BOOST_TEST(s1 == "123"); | |
66 | BOOST_TEST(s2 == "123"); | |
67 | BOOST_TEST(s3 == "123"); | |
68 | } | |
69 | catch (std::exception const& ex) | |
70 | { | |
71 | // Please be aware that the conversion requests above can fail. | |
72 | // Use try'n'catch blocks to handle any exceptions thrown. | |
73 | // Ignore this at your peril! | |
74 | std::cerr << "Exception " << ex.what() << std::endl; | |
75 | } | |
76 | //] [/getting_started_example1] | |
77 | } | |
78 | ||
79 | static | |
80 | void | |
81 | getting_started_example2() | |
82 | { | |
83 | //[getting_started_example2 | |
84 | // Does not throw. Returns fallback value (-1) when failed. | |
85 | int i = convert<int>("uhm", boost::cnv::lexical_cast()).value_or(-1); | |
86 | ||
87 | BOOST_TEST(i == -1); // Conversion failed. 'i' assigned the fallback value. | |
88 | //] | |
89 | } | |
90 | ||
91 | //[getting_started_headers3 | |
92 | #include <boost/convert/strtol.hpp> | |
93 | #include <boost/convert/spirit.hpp> | |
94 | //] | |
95 | ||
96 | static | |
97 | void | |
98 | getting_started_example3() | |
99 | { | |
100 | //[getting_started_example3 | |
101 | boost::cnv::lexical_cast cnv1; | |
102 | boost::cnv::strtol cnv2; | |
103 | boost::cnv::spirit cnv3; | |
104 | ||
105 | int i1 = convert<int>("123", cnv1).value(); | |
106 | int i2 = convert<int>("123", cnv2).value(); // Two times faster than lexical_cast. | |
107 | int i3 = convert<int>("123", cnv3).value(); // Four times faster than lexical_cast. | |
108 | //] | |
109 | } | |
110 | ||
111 | //[getting_started_headers4 | |
112 | #include <boost/convert/stream.hpp> | |
113 | //] | |
114 | ||
115 | static | |
116 | void | |
117 | getting_started_example4() | |
118 | { | |
119 | //[getting_started_example4 | |
120 | boost::cnv::cstream cnv; | |
121 | ||
122 | try | |
123 | { | |
124 | int i1 = lexical_cast<int>(" 123"); // Does not work. | |
125 | BOOST_TEST(!"Never reached"); | |
126 | } | |
127 | catch (...) {} | |
128 | ||
129 | int i2 = convert<int>(" 123", cnv(std::skipws)).value(); // Success | |
130 | string s1 = lexical_cast<string>(12.34567); | |
131 | string s2 = convert<string>(12.34567, cnv(std::fixed)(std::setprecision(3))).value(); | |
132 | string s3 = convert<string>(12.34567, cnv(std::scientific)(std::setprecision(3))).value(); | |
133 | string expected = local::is_msc ? "1.235e+001" : "1.235e+01"; | |
134 | ||
135 | BOOST_TEST(i2 == 123); // boost::cnv::cstream. Successfull conversion of " 123". | |
136 | BOOST_TEST(s1 == "12.34567"); // boost::lexical_cast. Precision is not configurable. | |
137 | BOOST_TEST(s2 == "12.346"); // boost::cnv::cstream. Precision was set to 3. Fixed. | |
138 | BOOST_TEST(s3 == expected); // boost::cnv::cstream. Precision was set to 3. Scientific. | |
139 | //] | |
140 | } | |
141 | ||
142 | static | |
143 | void | |
144 | getting_started_example5() | |
145 | { | |
146 | //[getting_started_example5 | |
147 | boost::cnv::cstream cnv; | |
148 | ||
149 | int i1 = lexical_cast<int>("123"); // Throws when conversion fails. | |
150 | int i2 = convert<int>("123", cnv).value(); // Throws when conversion fails. | |
151 | int i3 = convert<int>("uhm", cnv).value_or(-1); // Returns -1 when conversion fails. | |
152 | ||
153 | BOOST_TEST(i1 == 123); | |
154 | BOOST_TEST(i2 == 123); | |
155 | BOOST_TEST(i3 == -1); | |
156 | //] | |
157 | } | |
158 | ||
159 | static | |
160 | void | |
161 | getting_started_example6() | |
162 | { | |
163 | std::string const s1 = "123"; | |
164 | std::string const s2 = "456"; | |
165 | int const default_i1 = 11; | |
166 | int const default_i2 = 12; | |
167 | boost::cnv::cstream cnv; | |
168 | ||
169 | //[getting_started_example6 | |
170 | ||
171 | int i1 = convert<int>(s1, cnv(std::hex)).value_or(-1); // Read as hex | |
172 | int i2 = convert<int>(s2, cnv(std::dec)).value_or(-1); // Read as decimal | |
173 | ||
174 | if (i1 == -1) log("bad i1"), i1 = default_i1; // Log failure. Proceed with the default | |
175 | if (i2 == -1) log("bad i2"), i2 = default_i2; // Log failure. Proceed with the default | |
176 | ||
177 | // ... proceed | |
178 | //] | |
179 | BOOST_TEST(i1 == 291); | |
180 | BOOST_TEST(i2 == 456); | |
181 | } | |
182 | ||
183 | static | |
184 | void | |
185 | getting_started_example7() | |
186 | { | |
187 | std::string const s1 = "123"; | |
188 | std::string const s2 = "456"; | |
189 | int const default_i1 = 11; | |
190 | int const default_i2 = 12; | |
191 | boost::cnv::cstream cnv; | |
192 | ||
193 | //[getting_started_example7 | |
194 | ||
195 | int i1 = convert<int>(s1, cnv(std::hex)).value_or(default_i1); // If failed, proceed with the default | |
196 | int i2 = convert<int>(s2, cnv(std::dec)).value_or(default_i2); // If failed, proceed with the default | |
197 | // ... proceed | |
198 | //] | |
199 | BOOST_TEST(i1 == 291); | |
200 | BOOST_TEST(i2 == 456); | |
201 | } | |
202 | ||
203 | static | |
204 | //[getting_started_example9_func | |
205 | int | |
206 | fallback_fun(char const* msg, int fallback_value) | |
207 | { | |
208 | // The principal advantage of a fallback_func over a fallback_value | |
209 | // is that the former is only called when the conversion request fails. | |
210 | // Consequently, the returned fallback_value is only calculated (which | |
211 | // potentially might be expensive) when it is absolutely necessary. | |
212 | log(msg); return fallback_value; | |
213 | } | |
214 | //] | |
215 | static | |
216 | void | |
217 | getting_started_example9() | |
218 | { | |
219 | std::string const s1 = "123"; | |
220 | std::string const s2 = "456"; | |
221 | int const default_i1 = 11; | |
222 | int const default_i2 = 12; | |
223 | ||
224 | //[getting_started_example9 | |
225 | int i1 = convert<int>(s1).value_or_eval(boost::bind(fallback_fun, "bad i1", default_i1)); | |
226 | int i2 = convert<int>(s2).value_or_eval(boost::bind(fallback_fun, "bad i2", default_i2)); | |
227 | // ... proceed | |
228 | //] | |
229 | BOOST_TEST(i1 == 123); | |
230 | BOOST_TEST(i2 == 456); | |
231 | } | |
232 | ||
233 | static | |
234 | void | |
235 | getting_started_example8() | |
236 | { | |
237 | std::string const str = "123"; | |
238 | int const default_i1 = 12; | |
239 | //[getting_started_example8 | |
240 | int i1 = default_i1; | |
241 | ||
242 | try | |
243 | { | |
244 | i1 = lexical_cast<int>(str); | |
245 | } | |
246 | catch (...) | |
247 | { | |
248 | log("bad i1"); | |
249 | } | |
250 | //] | |
251 | BOOST_TEST(i1 == 123); | |
252 | } | |
253 | ||
254 | int | |
255 | main(int, char const* []) | |
256 | { | |
257 | getting_started_example1(); | |
258 | getting_started_example2(); | |
259 | getting_started_example3(); | |
260 | getting_started_example4(); | |
261 | getting_started_example5(); | |
262 | getting_started_example6(); | |
263 | getting_started_example7(); | |
264 | getting_started_example8(); | |
265 | getting_started_example9(); | |
266 | ||
267 | return boost::report_errors(); | |
268 | } |