sz_byteset_t bitset_;

public:

using char_type = char_type_;

sz_constexpr_if_cpp14 basic_byteset() noexcept {

// ! Instead of relying on the `sz_byteset_init`, we have to reimplement it to support `constexpr`.

bitset_._u64s[0] = 0, bitset_._u64s[1] = 0, bitset_._u64s[2] = 0, bitset_._u64s[3] = 0;

}

explicit sz_constexpr_if_cpp14 basic_byteset(std::initializer_list<char_type> chars) noexcept : basic_byteset() {

// ! Instead of relying on the `sz_byteset_add(&bitset_, c)`, we have to reimplement it to support `constexpr`.

for (auto c : chars) bitset_._u64s[sz_bitcast_(sz_u8_t, c) >> 6] |= (1ull << (sz_bitcast_(sz_u8_t, c) & 63u));

}

explicit sz_constexpr_if_cpp14 basic_byteset(char_type const *chars, std::size_t count_characters) noexcept

: basic_byteset() {

for (std::size_t i = 0; i < count_characters; ++i) {

char_type c = chars[i];

bitset_._u64s[sz_bitcast_(sz_u8_t, c) >> 6] |= (1ull << (sz_bitcast_(sz_u8_t, c) & 63u));

}

}

template <std::size_t count_characters>

explicit sz_constexpr_if_cpp14 basic_byteset(std::array<char_type, count_characters> const &chars) noexcept

: basic_byteset() {

static_assert(count_characters > 0, "Character array cannot be empty");

for (std::size_t i = 0; i < count_characters; ++i) {

char_type c = chars[i];

bitset_._u64s[sz_bitcast_(sz_u8_t, c) >> 6] |= (1ull << (sz_bitcast_(sz_u8_t, c) & 63u));

}

}

sz_constexpr_if_cpp14 basic_byteset(basic_byteset const &other) noexcept : bitset_(other.bitset_) {}

sz_constexpr_if_cpp14 basic_byteset &operator=(basic_byteset const &other) noexcept {

bitset_ = other.bitset_;

return *this;

}

sz_constexpr_if_cpp14 basic_byteset operator|(basic_byteset other) const noexcept {

basic_byteset result = *this; //? Variable declaration in a `constexpr` function is a C++14 extension

result.bitset_._u64s[0] |= other.bitset_._u64s[0], result.bitset_._u64s[1] |= other.bitset_._u64s[1],

result.bitset_._u64s[2] |= other.bitset_._u64s[2], result.bitset_._u64s[3] |= other.bitset_._u64s[3];

return result;

}

inline basic_byteset &add(char_type c) noexcept {

sz_byteset_add(&bitset_, sz_bitcast_(sz_u8_t, c));

return *this;

}

inline std::size_t size() const noexcept {

return //

sz_u64_popcount(bitset_._u64s[0]) + sz_u64_popcount(bitset_._u64s[1]) + //

sz_u64_popcount(bitset_._u64s[2]) + sz_u64_popcount(bitset_._u64s[3]);

}

inline sz_byteset_t &raw() noexcept { return bitset_; }

inline sz_byteset_t const &raw() const noexcept { return bitset_; }

inline bool contains(char_type c) const noexcept { return sz_byteset_contains(&bitset_, sz_bitcast_(sz_u8_t, c)); }

inline basic_byteset inverted() const noexcept {

basic_byteset result = *this;

sz_byteset_invert(&result.bitset_);

return result;

}

static_assert(sizeof(char_type_) == 1 || sizeof(char_type_) == 2 || sizeof(char_type_) == 4,

"Character type must be 1, 2, or 4 bytes long");

static constexpr std::size_t size_k = sizeof(char_type_) == 1 ? 256ul

: sizeof(char_type_) == 2 ? 65536ul

: 4294967296ul;

static constexpr std::size_t bytes_k = size_k * sizeof(char_type_);

using unsigned_type_ = typename std::make_unsigned<char_type_>::type;

char_type_ lut_[size_k];

public:

using char_type = char_type_;

basic_look_up_table() noexcept { memset(&lut_[0], 0, bytes_k); }

explicit basic_look_up_table(char_type const (&chars)[size_k]) noexcept { memcpy(&lut_[0], chars, bytes_k); }

basic_look_up_table(std::array<char_type, size_k> const &chars) noexcept {

memcpy(&lut_[0], chars.data(), bytes_k);

}

basic_look_up_table(basic_look_up_table const &other) noexcept { memcpy(&lut_[0], other.lut_, bytes_k); }

basic_look_up_table &operator=(basic_look_up_table const &other) noexcept {

memcpy(&lut_[0], other.lut_, bytes_k);

return *this;

}

/**

static basic_look_up_table identity() noexcept {

basic_look_up_table result;

for (std::size_t i = 0; i < size_k; ++i) { result.lut_[i] = static_cast<unsigned_type_>(i); }

return result;

}

inline sz_cptr_t raw() const noexcept { return reinterpret_cast<sz_cptr_t>(&lut_[0]); }

inline char_type &operator[](char_type c) noexcept { return lut_[sz_bitcast_(unsigned_type_, c)]; }

inline char_type const &operator[](char_type c) const noexcept { return lut_[sz_bitcast_(unsigned_type_, c)]; }

using size_type = typename string_type_::size_type;

needle_type_ needle_;

matcher_find(needle_type_ needle = {}) noexcept : needle_(needle) {}

size_type needle_length() const noexcept { return needle_.length(); }

size_type operator()(string_type_ haystack) const noexcept { return haystack.find(needle_); }

size_type skip_length() const noexcept {

// TODO: Apply Galil rule to match repetitive patterns in strictly linear time.

// Floor at 1 so an empty needle still advances.

return is_same_type<overlaps_type_, include_overlaps_type>::value //

? 1

: sz_max_of_two(needle_.length(), size_type(1));

}

using size_type = typename string_type_::size_type;

needle_type_ needle_;

matcher_rfind(needle_type_ needle = {}) noexcept : needle_(needle) {}

size_type needle_length() const noexcept { return needle_.length(); }

size_type operator()(string_type_ haystack) const noexcept { return haystack.rfind(needle_); }

size_type skip_length() const noexcept {

// TODO: Apply Galil rule to match repetitive patterns in strictly linear time.

// Floor at 1 so an empty needle still advances.

return is_same_type<overlaps_type_, include_overlaps_type>::value //

? 1

: sz_max_of_two(needle_.length(), size_type(1));

}

using size_type = typename haystack_type_::size_type;

needles_type_ needles_;

constexpr size_type needle_length() const noexcept { return 1; }

constexpr size_type skip_length() const noexcept { return 1; }

size_type operator()(haystack_type_ haystack) const noexcept { return haystack.find_first_of(needles_); }

using size_type = typename haystack_type_::size_type;

needles_type_ needles_;

constexpr size_type needle_length() const noexcept { return 1; }

constexpr size_type skip_length() const noexcept { return 1; }

size_type operator()(haystack_type_ haystack) const noexcept { return haystack.find_last_of(needles_); }

using size_type = typename haystack_type_::size_type;

needles_type_ needles_;

constexpr size_type needle_length() const noexcept { return 1; }

constexpr size_type skip_length() const noexcept { return 1; }

size_type operator()(haystack_type_ haystack) const noexcept { return haystack.find_first_not_of(needles_); }

using size_type = typename haystack_type_::size_type;

needles_type_ needles_;

constexpr size_type needle_length() const noexcept { return 1; }

constexpr size_type skip_length() const noexcept { return 1; }

size_type operator()(haystack_type_ haystack) const noexcept { return haystack.find_last_not_of(needles_); }

private:

template <typename candidate_>

static char test_(typename candidate_::string_view *);

template <typename candidate_>

static int test_(...);

public:

static constexpr bool value = sizeof(test_<type_>(0)) == sizeof(char);

private:

template <typename candidate_>

static char test_(candidate_ *candidate, decltype(candidate->remove_prefix(1)) * = nullptr);

template <typename candidate_>

static int test_(...);

public:

static constexpr bool value = sizeof(test_<type_>(nullptr)) == sizeof(char);

public:

using string_type = string_type_;

using matcher_type = matcher_type_;

using string_view_type = typename string_view_for<string_type>::type;

private:

matcher_type matcher_;

string_type haystack_;

public:

using size_type = std::size_t;

using difference_type = std::ptrdiff_t;

using value_type = string_view_type;

using pointer = string_view_type; // Needed for compatibility with STL container constructors.

using reference = string_view_type; // Needed for compatibility with STL container constructors.

find_matches_view(string_type haystack, matcher_type needle) noexcept

: matcher_(std::move(needle)), haystack_(std::move(haystack)) {}

class iterator {

matcher_type matcher_;

string_view_type remaining_;

public:

using iterator_category = std::forward_iterator_tag;

using difference_type = std::ptrdiff_t;

using value_type = string_view_type;

using pointer = string_view_type; // Needed for compatibility with STL container constructors.

using reference = string_view_type; // Needed for compatibility with STL container constructors.

iterator(string_view_type haystack, matcher_type matcher) noexcept : matcher_(matcher), remaining_(haystack) {

auto position = matcher_(remaining_);

remaining_.remove_prefix(position != string_type::npos ? position : remaining_.size());

}

pointer operator->() const noexcept = delete;

value_type operator*() const noexcept { return remaining_.substr(0, matcher_.needle_length()); }

iterator &operator++() noexcept {

remaining_.remove_prefix(matcher_.skip_length());

auto position = matcher_(remaining_);

remaining_.remove_prefix(position != string_type::npos ? position : remaining_.size());

return *this;

}

iterator operator++(int) noexcept {

iterator temp = *this;

++(*this);

return temp;

}

// Assumes both iterators point to the same underlying string.

bool operator!=(iterator const &other) const noexcept { return remaining_.data() != other.remaining_.data(); }

bool operator==(iterator const &other) const noexcept { return remaining_.data() == other.remaining_.data(); }

bool operator!=(end_sentinel_type) const noexcept { return !remaining_.empty(); }

bool operator==(end_sentinel_type) const noexcept { return remaining_.empty(); }

};

iterator begin() const noexcept { return {string_view_type(haystack_), matcher_}; }

iterator end() const noexcept { return {string_view_type(haystack_.data() + haystack_.size(), 0ull), matcher_}; }

size_type size() const noexcept { return static_cast<size_type>(ssize()); }

difference_type ssize() const noexcept { return std::distance(begin(), end()); }

bool empty() const noexcept { return begin() == end_sentinel_type {}; }

bool include_overlaps() const noexcept { return matcher_.skip_length() < matcher_.needle_length(); }

/** @brief Copies the matches into a container. */

template <typename container_>

void to(container_ &container) {

for (auto it_ = this->begin(); it_ != this->end(); ++it_) container.push_back(*it_);

}

/** @brief Copies the matches into a consumed container, returning it at the end. */

template <typename container_>

container_ to() {

return container_ {begin(), end()};

}

public:

using string_type = string_type_;

using matcher_type = matcher_type_;

using string_view_type = typename string_view_for<string_type>::type;

using size_type = std::size_t;

using difference_type = std::ptrdiff_t;

using value_type = string_view_type;

using pointer = string_view_type; // Needed for compatibility with STL container constructors.

using reference = string_view_type; // Needed for compatibility with STL container constructors.

private:

matcher_type matcher_;

string_type haystack_;

public:

rfind_matches_view(string_type haystack, matcher_type needle) noexcept

: matcher_(std::move(needle)), haystack_(std::move(haystack)) {}

class iterator {

matcher_type matcher_;

string_view_type remaining_;

public:

using iterator_category = std::forward_iterator_tag;

using difference_type = std::ptrdiff_t;

using value_type = string_view_type;

using pointer = string_view_type; // Needed for compatibility with STL container constructors.

using reference = string_view_type; // Needed for compatibility with STL container constructors.

iterator(string_view_type haystack, matcher_type matcher) noexcept : matcher_(matcher), remaining_(haystack) {

auto position = matcher_(remaining_);

remaining_.remove_suffix( //

position != string_type::npos //

? remaining_.size() - position - matcher_.needle_length()

: remaining_.size());

}

pointer operator->() const noexcept = delete;

value_type operator*() const noexcept {

return remaining_.substr(remaining_.size() - matcher_.needle_length());

}

iterator &operator++() noexcept {

remaining_.remove_suffix(matcher_.skip_length());

auto position = matcher_(remaining_);

remaining_.remove_suffix( //

position != string_type::npos //

? remaining_.size() - position - matcher_.needle_length()

: remaining_.size());

return *this;

}

iterator operator++(int) noexcept {

iterator temp = *this;

++(*this);

return temp;

}

// Assumes both iterators point to the same underlying string.

// This has to be `.data() + .size()`, to be compatible with `std::string_view` on MSVC.

bool operator!=(iterator const &other) const noexcept {

return remaining_.data() + remaining_.size() != other.remaining_.data() + other.remaining_.size();

}

bool operator==(iterator const &other) const noexcept {

return remaining_.data() + remaining_.size() == other.remaining_.data() + other.remaining_.size();

}

bool operator!=(end_sentinel_type) const noexcept { return !remaining_.empty(); }

bool operator==(end_sentinel_type) const noexcept { return remaining_.empty(); }

};

iterator begin() const noexcept { return {string_view_type(haystack_), matcher_}; }

iterator end() const noexcept { return {string_view_type(haystack_.data(), 0ull), matcher_}; }

size_type size() const noexcept { return static_cast<size_type>(ssize()); }

difference_type ssize() const noexcept { return std::distance(begin(), end()); }

bool empty() const noexcept { return begin() == end_sentinel_type {}; }

bool include_overlaps() const noexcept { return matcher_.skip_length() < matcher_.needle_length(); }

/** @brief Copies the matches into a container. */

template <typename container_>

void to(container_ &container) {

for (auto it_ = this->begin(); it_ != this->end(); ++it_) container.push_back(*it_);

}

/** @brief Copies the matches into a consumed container, returning it at the end. */

template <typename container_>

container_ to() {

return container_ {begin(), end()};

}

public:

using string_type = string_type_;

using matcher_type = matcher_type_;

using string_view_type = typename string_view_for<string_type>::type;

using size_type = std::size_t;

using difference_type = std::ptrdiff_t;

using value_type = string_view_type;

using pointer = string_view_type; // Needed for compatibility with STL container constructors.

using reference = string_view_type; // Needed for compatibility with STL container constructors.

private:

matcher_type matcher_;

string_type haystack_;

public:

find_splits_view(string_type haystack, matcher_type needle) noexcept

: matcher_(std::move(needle)), haystack_(std::move(haystack)) {}

class iterator {

char const *start_; // Start of current segment

char const *end_; // End of haystack (immutable)

size_type match_length_; // Length of current segment

matcher_type matcher_;

/** @brief Advance to the next segment (one delimiter). */

void advance_() noexcept {

start_ += match_length_;

if (start_ > end_) return;

if (start_ == end_) { // The final empty segment was just yielded; move past `end_` to terminate.

++start_, match_length_ = 0;

return;

}

// A zero-length delimiter (empty needle) still occupies one scan step, or `start_` would

// never move and the same zero-width match would repeat forever.

start_ += sz_max_of_two(matcher_.needle_length(), size_type(1));

if (start_ > end_) {

match_length_ = 0;

return;

}

string_view_type remaining(start_, static_cast<size_type>(end_ - start_));

auto position = matcher_(remaining);

match_length_ = position != string_type::npos ? position : remaining.size();

}

/** @brief When `skip_empty_`, advance past zero-length segments. No-op otherwise. */

void settle_() noexcept {

if (skip_empty_)

while (start_ <= end_ && match_length_ == 0) advance_();

}

public:

using iterator_category = std::forward_iterator_tag;

using difference_type = std::ptrdiff_t;

using value_type = string_view_type;

using pointer = string_view_type; // Needed for compatibility with STL container constructors.

using reference = string_view_type; // Needed for compatibility with STL container constructors.

iterator(string_view_type haystack, matcher_type matcher) noexcept

: start_(haystack.data()), end_(haystack.data() + haystack.size()), match_length_(0), matcher_(matcher) {

// Empty delimiter: no split.

if (matcher_.needle_length() == 0) {

match_length_ = haystack.size();

settle_();

return;

}

auto position = matcher_(haystack);

match_length_ = position != string_type::npos ? position : haystack.size();

settle_();

}

iterator(string_view_type haystack, matcher_type matcher, end_sentinel_type) noexcept

: start_(haystack.data() + haystack.size() + 1), end_(haystack.data() + haystack.size()), match_length_(0),

matcher_(matcher) {}

pointer operator->() const noexcept = delete;

value_type operator*() const noexcept { return string_view_type(start_, match_length_); }

iterator &operator++() noexcept {

advance_(), settle_();

return *this;

}

iterator operator++(int) noexcept {

iterator temp = *this;

++(*this);

return temp;

}

bool operator!=(iterator const &other) const noexcept { return start_ != other.start_; }

bool operator==(iterator const &other) const noexcept { return start_ == other.start_; }

bool operator!=(end_sentinel_type) const noexcept { return start_ <= end_; }

bool operator==(end_sentinel_type) const noexcept { return start_ > end_; }

bool is_last() const noexcept { return start_ + match_length_ == end_; }

};

iterator begin() const noexcept { return {string_view_type(haystack_), matcher_}; }

iterator end() const noexcept {

return {string_view_type(haystack_.end(), 0), matcher_, end_sentinel_type {}};

}

size_type size() const noexcept { return static_cast<size_type>(ssize()); }

difference_type ssize() const noexcept { return std::distance(begin(), end()); }

constexpr bool empty() const noexcept { return false; }

/** @brief Copies the matches into a container. */

template <typename container_>

void to(container_ &container) {

for (auto it_ = this->begin(); it_ != this->end(); ++it_) container.push_back(*it_);

}

/** @brief Copies the matches into a consumed container, returning it at the end. */

template <typename container_>

container_ to(container_ &&container = {}) {

for (auto it_ = this->begin(); it_ != this->end(); ++it_) container.push_back(*it_);

return std::move(container);

public:

using string_type = string_type_;

using matcher_type = matcher_type_;

using string_view_type = typename string_view_for<string_type>::type;

using size_type = std::size_t;

using difference_type = std::ptrdiff_t;

using value_type = string_view_type;

using pointer = string_view_type; // Needed for compatibility with STL container constructors.

using reference = string_view_type; // Needed for compatibility with STL container constructors.