]>
Commit | Line | Data |
---|---|---|
7c673cae FG |
1 | /*! |
2 | @file | |
3 | Defines `boost::hana::string`. | |
4 | ||
b32b8144 | 5 | @copyright Louis Dionne 2013-2017 |
7c673cae FG |
6 | Distributed under the Boost Software License, Version 1.0. |
7 | (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) | |
8 | */ | |
9 | ||
10 | #ifndef BOOST_HANA_STRING_HPP | |
11 | #define BOOST_HANA_STRING_HPP | |
12 | ||
13 | #include <boost/hana/fwd/string.hpp> | |
14 | ||
15 | #include <boost/hana/bool.hpp> | |
11fdf7f2 | 16 | #include <boost/hana/concept/constant.hpp> |
7c673cae FG |
17 | #include <boost/hana/config.hpp> |
18 | #include <boost/hana/core/make.hpp> | |
19 | #include <boost/hana/detail/algorithm.hpp> | |
20 | #include <boost/hana/detail/operators/adl.hpp> | |
21 | #include <boost/hana/detail/operators/comparable.hpp> | |
22 | #include <boost/hana/detail/operators/iterable.hpp> | |
23 | #include <boost/hana/detail/operators/orderable.hpp> | |
24 | #include <boost/hana/fwd/at.hpp> | |
25 | #include <boost/hana/fwd/contains.hpp> | |
26 | #include <boost/hana/fwd/core/tag_of.hpp> | |
27 | #include <boost/hana/fwd/core/to.hpp> | |
28 | #include <boost/hana/fwd/drop_front.hpp> | |
29 | #include <boost/hana/fwd/equal.hpp> | |
30 | #include <boost/hana/fwd/find.hpp> | |
31 | #include <boost/hana/fwd/front.hpp> | |
32 | #include <boost/hana/fwd/hash.hpp> | |
33 | #include <boost/hana/fwd/is_empty.hpp> | |
34 | #include <boost/hana/fwd/length.hpp> | |
35 | #include <boost/hana/fwd/less.hpp> | |
b32b8144 | 36 | #include <boost/hana/fwd/plus.hpp> |
7c673cae | 37 | #include <boost/hana/fwd/unpack.hpp> |
b32b8144 | 38 | #include <boost/hana/fwd/zero.hpp> |
7c673cae FG |
39 | #include <boost/hana/if.hpp> |
40 | #include <boost/hana/integral_constant.hpp> | |
41 | #include <boost/hana/optional.hpp> | |
42 | #include <boost/hana/type.hpp> | |
43 | ||
44 | #include <utility> | |
45 | #include <cstddef> | |
46 | #include <type_traits> | |
47 | ||
48 | ||
49 | BOOST_HANA_NAMESPACE_BEGIN | |
50 | ////////////////////////////////////////////////////////////////////////// | |
51 | // string<> | |
52 | ////////////////////////////////////////////////////////////////////////// | |
53 | //! @cond | |
b32b8144 FG |
54 | namespace detail { |
55 | template <char ...s> | |
56 | constexpr char const string_storage[sizeof...(s) + 1] = {s..., '\0'}; | |
57 | } | |
58 | ||
7c673cae FG |
59 | template <char ...s> |
60 | struct string | |
61 | : detail::operators::adl<string<s...>> | |
62 | , detail::iterable_operators<string<s...>> | |
b32b8144 FG |
63 | { |
64 | static constexpr char const* c_str() { | |
65 | return &detail::string_storage<s...>[0]; | |
66 | } | |
67 | }; | |
7c673cae FG |
68 | //! @endcond |
69 | ||
70 | template <char ...s> | |
71 | struct tag_of<string<s...>> { | |
72 | using type = string_tag; | |
73 | }; | |
74 | ||
75 | ////////////////////////////////////////////////////////////////////////// | |
76 | // make<string_tag> | |
77 | ////////////////////////////////////////////////////////////////////////// | |
78 | template <> | |
79 | struct make_impl<string_tag> { | |
80 | template <typename ...Chars> | |
81 | static constexpr auto apply(Chars const& ...) { | |
82 | return hana::string<hana::value<Chars>()...>{}; | |
83 | } | |
84 | }; | |
85 | ||
86 | ////////////////////////////////////////////////////////////////////////// | |
87 | // BOOST_HANA_STRING | |
88 | ////////////////////////////////////////////////////////////////////////// | |
89 | namespace string_detail { | |
90 | template <typename S, std::size_t ...N> | |
91 | constexpr string<S::get()[N]...> | |
92 | prepare_impl(S, std::index_sequence<N...>) | |
93 | { return {}; } | |
94 | ||
95 | template <typename S> | |
96 | constexpr decltype(auto) prepare(S s) { | |
97 | return prepare_impl(s, | |
98 | std::make_index_sequence<sizeof(S::get()) - 1>{}); | |
99 | } | |
100 | } | |
101 | ||
102 | #define BOOST_HANA_STRING(s) \ | |
103 | (::boost::hana::string_detail::prepare([]{ \ | |
104 | struct tmp { \ | |
105 | static constexpr decltype(auto) get() { return s; } \ | |
106 | }; \ | |
107 | return tmp{}; \ | |
108 | }())) \ | |
109 | /**/ | |
110 | ||
111 | #ifdef BOOST_HANA_CONFIG_ENABLE_STRING_UDL | |
112 | ////////////////////////////////////////////////////////////////////////// | |
113 | // _s user-defined literal | |
114 | ////////////////////////////////////////////////////////////////////////// | |
115 | namespace literals { | |
116 | template <typename CharT, CharT ...s> | |
117 | constexpr auto operator"" _s() { | |
118 | static_assert(std::is_same<CharT, char>::value, | |
119 | "hana::string: Only narrow string literals are supported with " | |
120 | "the _s string literal right now. See https://goo.gl/fBbKD7 " | |
121 | "if you need support for fancier types of compile-time strings."); | |
122 | return hana::string_c<s...>; | |
123 | } | |
124 | } | |
125 | #endif | |
126 | ||
127 | ////////////////////////////////////////////////////////////////////////// | |
128 | // Operators | |
129 | ////////////////////////////////////////////////////////////////////////// | |
130 | namespace detail { | |
131 | template <> | |
132 | struct comparable_operators<string_tag> { | |
133 | static constexpr bool value = true; | |
134 | }; | |
135 | template <> | |
136 | struct orderable_operators<string_tag> { | |
137 | static constexpr bool value = true; | |
138 | }; | |
139 | } | |
140 | ||
141 | ////////////////////////////////////////////////////////////////////////// | |
142 | // to<char const*> | |
143 | ////////////////////////////////////////////////////////////////////////// | |
144 | template <> | |
145 | struct to_impl<char const*, string_tag> { | |
7c673cae FG |
146 | template <char ...c> |
147 | static constexpr char const* apply(string<c...> const&) | |
b32b8144 | 148 | { return string<c...>::c_str(); } |
7c673cae FG |
149 | }; |
150 | ||
11fdf7f2 TL |
151 | ////////////////////////////////////////////////////////////////////////// |
152 | // to<string_tag> | |
153 | ////////////////////////////////////////////////////////////////////////// | |
154 | namespace detail { | |
155 | constexpr std::size_t cx_strlen(char const* s) { | |
156 | std::size_t n = 0u; | |
157 | while (*s != '\0') | |
158 | ++s, ++n; | |
159 | return n; | |
160 | } | |
161 | ||
162 | template <typename S, std::size_t ...I> | |
163 | constexpr hana::string<hana::value<S>()[I]...> expand(std::index_sequence<I...>) | |
164 | { return {}; } | |
165 | } | |
166 | ||
167 | template <typename IC> | |
168 | struct to_impl<hana::string_tag, IC, hana::when< | |
169 | hana::Constant<IC>::value && | |
170 | std::is_convertible<typename IC::value_type, char const*>::value | |
171 | >> { | |
172 | template <typename S> | |
173 | static constexpr auto apply(S const&) { | |
174 | constexpr char const* s = hana::value<S>(); | |
175 | constexpr std::size_t len = detail::cx_strlen(s); | |
176 | return detail::expand<S>(std::make_index_sequence<len>{}); | |
177 | } | |
178 | }; | |
179 | ||
7c673cae FG |
180 | ////////////////////////////////////////////////////////////////////////// |
181 | // Comparable | |
182 | ////////////////////////////////////////////////////////////////////////// | |
183 | template <> | |
184 | struct equal_impl<string_tag, string_tag> { | |
185 | template <typename S> | |
186 | static constexpr auto apply(S const&, S const&) | |
187 | { return hana::true_c; } | |
188 | ||
189 | template <typename S1, typename S2> | |
190 | static constexpr auto apply(S1 const&, S2 const&) | |
191 | { return hana::false_c; } | |
192 | }; | |
193 | ||
194 | ////////////////////////////////////////////////////////////////////////// | |
195 | // Orderable | |
196 | ////////////////////////////////////////////////////////////////////////// | |
197 | template <> | |
198 | struct less_impl<string_tag, string_tag> { | |
199 | template <char ...s1, char ...s2> | |
200 | static constexpr auto | |
201 | apply(string<s1...> const&, string<s2...> const&) { | |
202 | // We put a '\0' at the end only to avoid empty arrays. | |
203 | constexpr char const c_str1[] = {s1..., '\0'}; | |
204 | constexpr char const c_str2[] = {s2..., '\0'}; | |
205 | return hana::bool_c<detail::lexicographical_compare( | |
206 | c_str1, c_str1 + sizeof...(s1), | |
207 | c_str2, c_str2 + sizeof...(s2) | |
208 | )>; | |
209 | } | |
210 | }; | |
211 | ||
b32b8144 FG |
212 | ////////////////////////////////////////////////////////////////////////// |
213 | // Monoid | |
214 | ////////////////////////////////////////////////////////////////////////// | |
215 | template <> | |
216 | struct plus_impl<string_tag, string_tag> { | |
217 | template <char ...s1, char ...s2> | |
218 | static constexpr auto | |
219 | apply(string<s1...> const&, string<s2...> const&) { | |
220 | return string<s1..., s2...>{}; | |
221 | } | |
222 | }; | |
223 | ||
224 | template <> | |
225 | struct zero_impl<string_tag> { | |
226 | static constexpr auto apply() { | |
227 | return string<>{}; | |
228 | } | |
229 | }; | |
230 | ||
231 | template <char ...s1, char ...s2> | |
232 | constexpr auto operator+(string<s1...> const&, string<s2...> const&) { | |
233 | return hana::string<s1..., s2...>{}; | |
234 | } | |
235 | ||
7c673cae FG |
236 | ////////////////////////////////////////////////////////////////////////// |
237 | // Foldable | |
238 | ////////////////////////////////////////////////////////////////////////// | |
239 | template <> | |
240 | struct unpack_impl<string_tag> { | |
241 | template <char ...s, typename F> | |
242 | static constexpr decltype(auto) apply(string<s...> const&, F&& f) | |
243 | { return static_cast<F&&>(f)(char_<s>{}...); } | |
244 | }; | |
245 | ||
246 | template <> | |
247 | struct length_impl<string_tag> { | |
248 | template <char ...s> | |
249 | static constexpr auto apply(string<s...> const&) | |
250 | { return hana::size_c<sizeof...(s)>; } | |
251 | }; | |
252 | ||
253 | ////////////////////////////////////////////////////////////////////////// | |
254 | // Iterable | |
255 | ////////////////////////////////////////////////////////////////////////// | |
256 | template <> | |
257 | struct front_impl<string_tag> { | |
258 | template <char x, char ...xs> | |
259 | static constexpr auto apply(string<x, xs...> const&) | |
260 | { return hana::char_c<x>; } | |
261 | }; | |
262 | ||
263 | template <> | |
264 | struct drop_front_impl<string_tag> { | |
265 | template <std::size_t N, char ...xs, std::size_t ...i> | |
266 | static constexpr auto helper(string<xs...> const&, std::index_sequence<i...>) { | |
267 | constexpr char s[] = {xs...}; | |
268 | return hana::string_c<s[i + N]...>; | |
269 | } | |
270 | ||
271 | template <char ...xs, typename N> | |
272 | static constexpr auto apply(string<xs...> const& s, N const&) { | |
273 | return helper<N::value>(s, std::make_index_sequence< | |
92f5a8d4 | 274 | (N::value < sizeof...(xs)) ? sizeof...(xs) - N::value : 0 |
7c673cae FG |
275 | >{}); |
276 | } | |
277 | ||
278 | template <typename N> | |
279 | static constexpr auto apply(string<> const& s, N const&) | |
280 | { return s; } | |
281 | }; | |
282 | ||
283 | template <> | |
284 | struct is_empty_impl<string_tag> { | |
285 | template <char ...s> | |
286 | static constexpr auto apply(string<s...> const&) | |
287 | { return hana::bool_c<sizeof...(s) == 0>; } | |
288 | }; | |
289 | ||
290 | template <> | |
291 | struct at_impl<string_tag> { | |
292 | template <char ...s, typename N> | |
293 | static constexpr auto apply(string<s...> const&, N const&) { | |
294 | // We put a '\0' at the end to avoid an empty array. | |
295 | constexpr char characters[] = {s..., '\0'}; | |
296 | constexpr auto n = N::value; | |
297 | return hana::char_c<characters[n]>; | |
298 | } | |
299 | }; | |
300 | ||
301 | ////////////////////////////////////////////////////////////////////////// | |
302 | // Searchable | |
303 | ////////////////////////////////////////////////////////////////////////// | |
304 | template <> | |
305 | struct contains_impl<string_tag> { | |
306 | template <char ...s, typename C> | |
307 | static constexpr auto | |
308 | helper(string<s...> const&, C const&, hana::true_) { | |
309 | constexpr char const characters[] = {s..., '\0'}; | |
310 | constexpr char c = hana::value<C>(); | |
311 | return hana::bool_c< | |
312 | detail::find(characters, characters + sizeof...(s), c) | |
313 | != characters + sizeof...(s) | |
314 | >; | |
315 | } | |
316 | ||
317 | template <typename S, typename C> | |
318 | static constexpr auto helper(S const&, C const&, hana::false_) | |
319 | { return hana::false_c; } | |
320 | ||
321 | template <typename S, typename C> | |
322 | static constexpr auto apply(S const& s, C const& c) | |
323 | { return helper(s, c, hana::bool_c<hana::Constant<C>::value>); } | |
324 | }; | |
325 | ||
326 | template <> | |
327 | struct find_impl<string_tag> { | |
328 | template <char ...s, typename Char> | |
329 | static constexpr auto apply(string<s...> const& str, Char const& c) { | |
330 | return hana::if_(contains_impl<string_tag>::apply(str, c), | |
331 | hana::just(c), | |
332 | hana::nothing | |
333 | ); | |
334 | } | |
335 | }; | |
336 | ||
337 | ////////////////////////////////////////////////////////////////////////// | |
338 | // Hashable | |
339 | ////////////////////////////////////////////////////////////////////////// | |
340 | template <> | |
341 | struct hash_impl<string_tag> { | |
342 | template <typename String> | |
343 | static constexpr auto apply(String const&) { | |
344 | return hana::type_c<String>; | |
345 | } | |
346 | }; | |
347 | BOOST_HANA_NAMESPACE_END | |
348 | ||
349 | #endif // !BOOST_HANA_STRING_HPP |