QStringTokenizer Class

Member Function Documentation

Constructs a string tokenizer that splits the string haystack into substrings wherever needle occurs, and allows iteration over those strings as they are found. If needle does not match anywhere in haystack, a single element containing haystack is produced.

cs specifies whether needle should be matched case sensitively or case insensitively.

If sb is Qt::SkipEmptyParts, empty entries don't appear in the result. By default, empty entries are included.

See also QStringView::split(), QString::split(), Qt::CaseSensitivity, and Qt::SplitBehavior.

Returns a const STL-style iterator pointing to the first token in the list.

See also end() and cend().

[constexpr noexcept] QStringTokenizer<Haystack, Needle>::sentinel QStringTokenizer::cend() const

Same as end().

See also cbegin() and end().

[constexpr noexcept] QStringTokenizer<Haystack, Needle>::sentinel QStringTokenizer::end() const

Returns a const STL-style sentinel pointing to the imaginary token after the last token in the list.

See also begin() and cend().

template <typename LContainer> LContainer QStringTokenizer::toContainer(LContainer &&c = {}) const &

Converts the lazy sequence into a (typically) random-access container of type LContainer.

This function is only available if Container has a value_type matching this tokenizer's value_type.

If you pass in a named container (an lvalue) for c, then that container is filled, and a reference to it is returned. If you pass in a temporary container (an rvalue, incl. the default argument), then that container is filled, and returned by value.

 // assuming tok's value_type is QStringView, then...
 auto tok = QStringTokenizer{~~~};
 // ... rac1 is a QList:
 auto rac1 = tok.toContainer();
 // ... rac2 is std::pmr::vector<QStringView>:
 auto rac2 = tok.toContainer<std::pmr::vector<QStringView>>();
 auto rac3 = QVarLengthArray<QStringView, 12>{};
 // appends the token sequence produced by tok to rac3
 //  and returns a reference to rac3 (which we ignore here):
 tok.toContainer(rac3);

This gives you maximum flexibility in how you want the sequence to be stored.

template <typename RContainer> RContainer QStringTokenizer::toContainer(RContainer &&c = {}) const &&

This is an overloaded function.

Converts the lazy sequence into a (typically) random-access container of type RContainer.

In addition to the constraints on the lvalue-this overload, this rvalue-this overload is only available when this QStringTokenizer does not store the haystack internally, as this could create a container full of dangling references:

 auto tokens = QStringTokenizer{widget.text(), u','}.toContainer();
 // ERROR: cannot call toContainer() on rvalue
 // 'tokens' references the data of the copy of widget.text()
 // stored inside the QStringTokenizer, which has since been deleted

To fix, store the QStringTokenizer in a temporary:

 auto tokenizer = QStringTokenizer{widget.text90, u','};
 auto tokens = tokenizer.toContainer();
 // OK: the copy of widget.text() stored in 'tokenizer' keeps the data
 // referenced by 'tokens' alive.

You can force this function into existence by passing a view instead:

 func(QStringTokenizer{QStringView{widget.text()}, u','}.toContainer());
 // OK: compiler keeps widget.text() around until after func() has executed

If you pass in a named container (an lvalue)for c, then that container is filled, and a reference to it is returned. If you pass in a temporary container (an rvalue, incl. the default argument), then that container is filled, and returned by value.