1// Copyright (C) 2020 Klarälvdalens Datakonsult AB, a KDAB Group company, info@kdab.com, author Marc Mutz <marc.mutz@kdab.com>
2// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
3#ifndef QUTF8STRINGVIEW_H
4#define QUTF8STRINGVIEW_H
5
6#if 0
7#pragma qt_class(QUtf8StringView)
8#endif
9
10#include <QtCore/qstringalgorithms.h>
11#include <QtCore/qstringfwd.h>
12#include <QtCore/qarraydata.h> // for QContainerImplHelper
13#include <QtCore/qbytearrayview.h>
14#include <QtCore/qcompare.h>
15#include <QtCore/qcontainerfwd.h>
16
17#include <string>
18#include <string_view>
19#include <QtCore/q20type_traits.h>
20
21QT_BEGIN_NAMESPACE
22
23namespace QtPrivate {
24template <typename Char>
25using IsCompatibleChar8TypeHelper = std::disjunction<
26#ifdef __cpp_char8_t
27 std::is_same<Char, char8_t>,
28#endif
29 std::is_same<Char, char>,
30 std::is_same<Char, uchar>,
31 std::is_same<Char, signed char>
32 >;
33template <typename Char>
34using IsCompatibleChar8Type
35 = IsCompatibleChar8TypeHelper<q20::remove_cvref_t<Char>>;
36
37template <typename Pointer>
38struct IsCompatiblePointer8Helper : std::false_type {};
39template <typename Char>
40struct IsCompatiblePointer8Helper<Char*>
41 : IsCompatibleChar8Type<Char> {};
42template <typename Pointer>
43using IsCompatiblePointer8
44 = IsCompatiblePointer8Helper<q20::remove_cvref_t<Pointer>>;
45
46template <typename T, typename Enable = void>
47struct IsContainerCompatibleWithQUtf8StringView : std::false_type {};
48
49template <typename T>
50struct IsContainerCompatibleWithQUtf8StringView<T, std::enable_if_t<std::conjunction_v<
51 // lacking concepts and ranges, we accept any T whose std::data yields a suitable pointer ...
52 IsCompatiblePointer8<decltype(std::data(std::declval<const T &>()))>,
53 // ... and that has a suitable size ...
54 std::is_convertible<
55 decltype(std::size(std::declval<const T &>())),
56 qsizetype
57 >,
58 // ... and it's a range as it defines an iterator-like API
59 IsCompatibleChar8Type<typename std::iterator_traits<
60 decltype(std::begin(std::declval<const T &>()))>::value_type
61 >,
62 std::is_convertible<
63 decltype( std::begin(std::declval<const T &>()) != std::end(std::declval<const T &>()) ),
64 bool
65 >,
66
67 // This needs to be treated specially due to the empty vs null distinction
68 std::negation<std::is_same<std::decay_t<T>, QByteArray>>,
69
70 // This has a compatible value_type, but explicitly a different encoding
71 std::negation<std::is_same<std::decay_t<T>, QLatin1StringView>>,
72
73 // Don't make an accidental copy constructor
74 std::negation<std::disjunction<
75 std::is_same<std::decay_t<T>, QBasicUtf8StringView<true>>,
76 std::is_same<std::decay_t<T>, QBasicUtf8StringView<false>>
77 >>
78 >>> : std::true_type {};
79
80struct hide_char8_t {
81#ifdef __cpp_char8_t
82 using type = char8_t;
83#endif
84};
85
86struct wrap_char { using type = char; };
87
88} // namespace QtPrivate
89
90#ifdef Q_QDOC
91#define QBasicUtf8StringView QUtf8StringView
92#else
93template <bool UseChar8T>
94#endif
95class QBasicUtf8StringView
96{
97public:
98#ifndef Q_QDOC
99 using storage_type = typename std::conditional<UseChar8T,
100 QtPrivate::hide_char8_t,
101 QtPrivate::wrap_char
102 >::type::type;
103#else
104 using storage_type = typename QtPrivate::hide_char8_t;
105#endif
106 typedef const storage_type value_type;
107 typedef qptrdiff difference_type;
108 typedef qsizetype size_type;
109 typedef value_type &reference;
110 typedef value_type &const_reference;
111 typedef value_type *pointer;
112 typedef value_type *const_pointer;
113
114 typedef pointer iterator;
115 typedef const_pointer const_iterator;
116 typedef std::reverse_iterator<iterator> reverse_iterator;
117 typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
118
119private:
120 template <typename Char>
121 using if_compatible_char = std::enable_if_t<QtPrivate::IsCompatibleChar8Type<Char>::value, bool>;
122
123 template <typename Pointer>
124 using if_compatible_pointer = std::enable_if_t<QtPrivate::IsCompatiblePointer8<Pointer>::value, bool>;
125
126 template <typename T>
127 using if_compatible_qstring_like = std::enable_if_t<std::is_same_v<T, QByteArray>, bool>;
128
129 template <typename T>
130 using if_compatible_container = std::enable_if_t<QtPrivate::IsContainerCompatibleWithQUtf8StringView<T>::value, bool>;
131
132 template <typename Container>
133 static constexpr qsizetype lengthHelperContainer(const Container &c) noexcept
134 {
135 return qsizetype(std::size(c));
136 }
137
138 // Note: Do not replace with std::size(const Char (&)[N]), because the result
139 // will be of by one.
140 template <typename Char, size_t N>
141 static constexpr qsizetype lengthHelperContainer(const Char (&str)[N]) noexcept
142 {
143 return QtPrivate::lengthHelperContainer(str);
144 }
145
146 template <typename Char>
147 static const storage_type *castHelper(const Char *str) noexcept
148 { return reinterpret_cast<const storage_type*>(str); }
149 static constexpr const storage_type *castHelper(const storage_type *str) noexcept
150 { return str; }
151
152public:
153 constexpr QBasicUtf8StringView() noexcept
154 : m_data(nullptr), m_size(0) {}
155 constexpr QBasicUtf8StringView(std::nullptr_t) noexcept
156 : QBasicUtf8StringView() {}
157
158 template <typename Char, if_compatible_char<Char> = true>
159 constexpr QBasicUtf8StringView(const Char *str, qsizetype len)
160 : m_data(castHelper(str)),
161 m_size((Q_ASSERT(len >= 0), Q_ASSERT(str || !len), len)) {}
162
163 template <typename Char, if_compatible_char<Char> = true>
164 constexpr QBasicUtf8StringView(const Char *f, const Char *l)
165 : QBasicUtf8StringView(f, l - f) {}
166
167#ifdef Q_QDOC
168 template <typename Char, size_t N>
169 constexpr QBasicUtf8StringView(const Char (&array)[N]) noexcept;
170
171 template <typename Char>
172 constexpr QBasicUtf8StringView(const Char *str) noexcept;
173#else
174 template <typename Pointer, if_compatible_pointer<Pointer> = true>
175 constexpr QBasicUtf8StringView(const Pointer &str) noexcept
176 : QBasicUtf8StringView(str, QtPrivate::lengthHelperPointer(str)) {}
177#endif
178
179#ifdef Q_QDOC
180 QBasicUtf8StringView(const QByteArray &str) noexcept;
181 constexpr QBasicUtf8StringView(const storage_type *d, qsizetype n) noexcept {};
182#else
183 template <typename String, if_compatible_qstring_like<String> = true>
184 QBasicUtf8StringView(const String &str) noexcept
185 : QBasicUtf8StringView{str.begin(), str.size()} {}
186#endif
187
188 template <typename Container, if_compatible_container<Container> = true>
189 constexpr QBasicUtf8StringView(const Container &c) noexcept
190 : QBasicUtf8StringView(std::data(c), lengthHelperContainer(c)) {}
191
192#if defined(__cpp_char8_t) && !defined(Q_QDOC)
193 constexpr QBasicUtf8StringView(QBasicUtf8StringView<!UseChar8T> other)
194 : QBasicUtf8StringView(other.data(), other.size()) {}
195#endif
196
197 template <typename Char, size_t Size, if_compatible_char<Char> = true>
198 [[nodiscard]] constexpr static QBasicUtf8StringView fromArray(const Char (&string)[Size]) noexcept
199 { return QBasicUtf8StringView(string, Size); }
200
201 [[nodiscard]] inline QString toString() const; // defined in qstring.h
202
203 [[nodiscard]] constexpr qsizetype size() const noexcept { return m_size; }
204 [[nodiscard]] constexpr const_pointer data() const noexcept { return m_data; }
205#ifdef __cpp_char8_t
206 [[nodiscard]] const char8_t *utf8() const noexcept { return reinterpret_cast<const char8_t*>(m_data); }
207#endif
208
209 [[nodiscard]] constexpr storage_type operator[](qsizetype n) const
210 { verify(pos: n, n: 1); return m_data[n]; }
211
212 //
213 // QString API
214 //
215
216 [[nodiscard]] constexpr storage_type at(qsizetype n) const { return (*this)[n]; }
217
218 [[nodiscard]]
219 constexpr QBasicUtf8StringView mid(qsizetype pos, qsizetype n = -1) const
220 {
221 using namespace QtPrivate;
222 auto result = QContainerImplHelper::mid(originalLength: size(), position: &pos, length: &n);
223 return result == QContainerImplHelper::Null ? QBasicUtf8StringView() : QBasicUtf8StringView(m_data + pos, n);
224 }
225 [[nodiscard]]
226 constexpr QBasicUtf8StringView left(qsizetype n) const
227 {
228 if (size_t(n) >= size_t(size()))
229 n = size();
230 return QBasicUtf8StringView(m_data, n);
231 }
232 [[nodiscard]]
233 constexpr QBasicUtf8StringView right(qsizetype n) const
234 {
235 if (size_t(n) >= size_t(size()))
236 n = size();
237 return QBasicUtf8StringView(m_data + m_size - n, n);
238 }
239
240 [[nodiscard]] constexpr QBasicUtf8StringView sliced(qsizetype pos) const
241 { verify(pos, n: 0); return QBasicUtf8StringView{m_data + pos, m_size - pos}; }
242 [[nodiscard]] constexpr QBasicUtf8StringView sliced(qsizetype pos, qsizetype n) const
243 { verify(pos, n); return QBasicUtf8StringView(m_data + pos, n); }
244 [[nodiscard]] constexpr QBasicUtf8StringView first(qsizetype n) const
245 { verify(pos: 0, n); return sliced(0, n); }
246 [[nodiscard]] constexpr QBasicUtf8StringView last(qsizetype n) const
247 { verify(pos: 0, n); return sliced(m_size - n, n); }
248 [[nodiscard]] constexpr QBasicUtf8StringView chopped(qsizetype n) const
249 { verify(pos: 0, n); return sliced(0, m_size - n); }
250
251 constexpr QBasicUtf8StringView &slice(qsizetype pos)
252 { *this = sliced(pos); return *this; }
253 constexpr QBasicUtf8StringView &slice(qsizetype pos, qsizetype n)
254 { *this = sliced(pos, n); return *this; }
255
256 constexpr void truncate(qsizetype n)
257 { verify(pos: 0, n); m_size = n; }
258 constexpr void chop(qsizetype n)
259 { verify(pos: 0, n); m_size -= n; }
260
261 [[nodiscard]] inline bool isValidUtf8() const noexcept
262 {
263 return QByteArrayView(reinterpret_cast<const char *>(data()), size()).isValidUtf8();
264 }
265
266 //
267 // STL compatibility API:
268 //
269 [[nodiscard]] const_iterator begin() const noexcept { return data(); }
270 [[nodiscard]] const_iterator end() const noexcept { return data() + size(); }
271 [[nodiscard]] const_iterator cbegin() const noexcept { return begin(); }
272 [[nodiscard]] const_iterator cend() const noexcept { return end(); }
273 [[nodiscard]] const_reverse_iterator rbegin() const noexcept { return const_reverse_iterator(end()); }
274 [[nodiscard]] const_reverse_iterator rend() const noexcept { return const_reverse_iterator(begin()); }
275 [[nodiscard]] const_reverse_iterator crbegin() const noexcept { return rbegin(); }
276 [[nodiscard]] const_reverse_iterator crend() const noexcept { return rend(); }
277
278 [[nodiscard]] constexpr bool empty() const noexcept { return size() == 0; }
279 [[nodiscard]] constexpr storage_type front() const { return Q_ASSERT(!empty()), m_data[0]; }
280 [[nodiscard]] constexpr storage_type back() const { return Q_ASSERT(!empty()), m_data[m_size - 1]; }
281
282 [[nodiscard]] Q_IMPLICIT operator std::basic_string_view<storage_type>() const noexcept
283 { return std::basic_string_view<storage_type>(data(), size_t(size())); }
284
285 [[nodiscard]] constexpr qsizetype max_size() const noexcept { return maxSize(); }
286
287 //
288 // Qt compatibility API:
289 //
290 [[nodiscard]] constexpr bool isNull() const noexcept { return !m_data; }
291 [[nodiscard]] constexpr bool isEmpty() const noexcept { return empty(); }
292 [[nodiscard]] constexpr qsizetype length() const noexcept
293 { return size(); }
294
295 [[nodiscard]] int compare(QBasicUtf8StringView other,
296 Qt::CaseSensitivity cs = Qt::CaseSensitive) const noexcept
297 {
298 return QtPrivate::compareStrings(*this, other, cs);
299 }
300
301 // all defined in qstring.h
302 [[nodiscard]] inline int compare(QChar other,
303 Qt::CaseSensitivity cs = Qt::CaseSensitive) const noexcept;
304 [[nodiscard]] inline int compare(QStringView other,
305 Qt::CaseSensitivity cs = Qt::CaseSensitive) const noexcept;
306 [[nodiscard]] inline int compare(QLatin1StringView other,
307 Qt::CaseSensitivity cs = Qt::CaseSensitive) const noexcept;
308 [[nodiscard]] inline int compare(const QByteArray &other,
309 Qt::CaseSensitivity cs = Qt::CaseSensitive) const noexcept;
310
311 [[nodiscard]] inline bool equal(QChar other) const noexcept;
312 [[nodiscard]] inline bool equal(QStringView other) const noexcept;
313 [[nodiscard]] inline bool equal(QLatin1StringView other) const noexcept;
314 [[nodiscard]] inline bool equal(const QByteArray &other) const noexcept;
315 // end defined in qstring.h
316
317 [[nodiscard]] static constexpr qsizetype maxSize() noexcept
318 {
319 // -1 to deal with the pointer one-past-the-end;
320 return QtPrivate::MaxAllocSize - 1;
321 }
322
323private:
324 [[nodiscard]] static inline int compare(QBasicUtf8StringView lhs, QBasicUtf8StringView rhs) noexcept
325 {
326 return QtPrivate::compareStrings(lhs: QBasicUtf8StringView<false>(lhs.data(), lhs.size()),
327 rhs: QBasicUtf8StringView<false>(rhs.data(), rhs.size()));
328 }
329
330 friend bool
331 comparesEqual(const QBasicUtf8StringView &lhs, const QBasicUtf8StringView &rhs) noexcept
332 {
333 return lhs.size() == rhs.size()
334 && QtPrivate::equalStrings(lhs: QBasicUtf8StringView<false>(lhs.data(), lhs.size()),
335 rhs: QBasicUtf8StringView<false>(rhs.data(), rhs.size()));
336 }
337 friend Qt::strong_ordering
338 compareThreeWay(const QBasicUtf8StringView &lhs, const QBasicUtf8StringView &rhs) noexcept
339 {
340 const int res = QBasicUtf8StringView::compare(lhs, rhs);
341 return Qt::compareThreeWay(lhs: res, rhs: 0);
342 }
343 Q_DECLARE_STRONGLY_ORDERED(QBasicUtf8StringView)
344
345 friend bool
346 comparesEqual(const QBasicUtf8StringView &lhs, const QLatin1StringView &rhs) noexcept
347 {
348 return lhs.equal(rhs);
349 }
350 friend Qt::strong_ordering
351 compareThreeWay(const QBasicUtf8StringView &lhs, const QLatin1StringView &rhs) noexcept
352 {
353 const int res = lhs.compare(rhs);
354 return Qt::compareThreeWay(lhs: res, rhs: 0);
355 }
356 Q_DECLARE_STRONGLY_ORDERED(QBasicUtf8StringView, QLatin1StringView)
357
358 friend bool
359 comparesEqual(const QBasicUtf8StringView &lhs, const QStringView &rhs) noexcept
360 { return lhs.equal(rhs); }
361 friend Qt::strong_ordering
362 compareThreeWay(const QBasicUtf8StringView &lhs, const QStringView &rhs) noexcept
363 {
364 const int res = lhs.compare(rhs);
365 return Qt::compareThreeWay(lhs: res, rhs: 0);
366 }
367 Q_DECLARE_STRONGLY_ORDERED(QBasicUtf8StringView, QStringView)
368
369 friend bool comparesEqual(const QBasicUtf8StringView &lhs, const QChar &rhs) noexcept
370 { return lhs.equal(rhs); }
371 friend Qt::strong_ordering
372 compareThreeWay(const QBasicUtf8StringView &lhs, const QChar &rhs) noexcept
373 {
374 const int res = lhs.compare(rhs);
375 return Qt::compareThreeWay(lhs: res, rhs: 0);
376 }
377 Q_DECLARE_STRONGLY_ORDERED(QBasicUtf8StringView, QChar)
378 Q_DECLARE_STRONGLY_ORDERED(QBasicUtf8StringView, char16_t)
379
380#if !defined(QT_NO_CAST_FROM_ASCII) && !defined(QT_RESTRICTED_CAST_FROM_ASCII)
381 friend bool
382 comparesEqual(const QBasicUtf8StringView &lhs, const QByteArrayView &rhs) noexcept
383 {
384 return lhs.size() == rhs.size()
385 && QtPrivate::equalStrings(lhs: QBasicUtf8StringView<false>(lhs.data(), lhs.size()),
386 rhs: QBasicUtf8StringView<false>(rhs.data(), rhs.size()));
387 }
388 friend Qt::strong_ordering
389 compareThreeWay(const QBasicUtf8StringView &lhs, const QByteArrayView &rhs) noexcept
390 {
391 const int res = QtPrivate::compareStrings(lhs: QBasicUtf8StringView<false>(lhs.data(), lhs.size()),
392 rhs: QBasicUtf8StringView<false>(rhs.data(), rhs.size()));
393 return Qt::compareThreeWay(lhs: res, rhs: 0);
394 }
395 Q_DECLARE_STRONGLY_ORDERED(QBasicUtf8StringView, QByteArrayView, QT_ASCII_CAST_WARN)
396
397 friend bool
398 comparesEqual(const QBasicUtf8StringView &lhs, const QByteArray &rhs) noexcept
399 {
400 return lhs.equal(rhs);
401 }
402 friend Qt::strong_ordering
403 compareThreeWay(const QBasicUtf8StringView &lhs, const QByteArray &rhs) noexcept
404 {
405 const int res = lhs.compare(rhs);
406 return Qt::compareThreeWay(lhs: res, rhs: 0);
407 }
408 Q_DECLARE_STRONGLY_ORDERED(QBasicUtf8StringView, QByteArray, QT_ASCII_CAST_WARN)
409
410 friend bool comparesEqual(const QBasicUtf8StringView &lhs, const char *rhs) noexcept
411 { return comparesEqual(lhs, QByteArrayView(rhs)); }
412 friend Qt::strong_ordering
413 compareThreeWay(const QBasicUtf8StringView &lhs, const char *rhs) noexcept
414 { return compareThreeWay(lhs, QByteArrayView(rhs)); }
415 Q_DECLARE_STRONGLY_ORDERED(QBasicUtf8StringView, const char *, QT_ASCII_CAST_WARN)
416#endif // !defined(QT_NO_CAST_FROM_ASCII) && !defined(QT_RESTRICTED_CAST_FROM_ASCII)
417
418 Q_ALWAYS_INLINE constexpr void verify([[maybe_unused]] qsizetype pos = 0,
419 [[maybe_unused]] qsizetype n = 1) const
420 {
421 Q_ASSERT(pos >= 0);
422 Q_ASSERT(pos <= size());
423 Q_ASSERT(n >= 0);
424 Q_ASSERT(n <= size() - pos);
425 }
426 const storage_type *m_data;
427 qsizetype m_size;
428};
429
430#ifdef Q_QDOC
431#undef QBasicUtf8StringView
432#else
433template <bool UseChar8T>
434Q_DECLARE_TYPEINFO_BODY(QBasicUtf8StringView<UseChar8T>, Q_PRIMITIVE_TYPE);
435
436template <typename QStringLike, std::enable_if_t<std::is_same_v<QStringLike, QByteArray>, bool> = true>
437[[nodiscard]] inline q_no_char8_t::QUtf8StringView qToUtf8StringViewIgnoringNull(const QStringLike &s) noexcept
438{ return q_no_char8_t::QUtf8StringView(s.begin(), s.size()); }
439#endif // Q_QDOC
440
441QT_END_NAMESPACE
442
443#endif /* QUTF8STRINGVIEW_H */
444

Provided by KDAB

Privacy Policy
Learn to use CMake with our Intro Training
Find out more

source code of qtbase/src/corelib/text/qutf8stringview.h