TextView.h

Go to the documentation of this file.

// SPDX-License-Identifier: Apache-2.0
// Copyright Apache Software Foundation 2019
 
#pragma once
#include <bitset>
#include <cstdint>
#include <iosfwd>
#include <memory.h>
#include <string>
#include <string_view>
#include <limits>
#include <type_traits>
 
#include "swoc/swoc_version.h"
#include "swoc/string_view_util.h"
 
// For no apparent reason, g++ 11 complains about array bound violations with either suffix_at or
// assign, the error message is too vague for me to be sure - it doesn't even provide the location of
// the method invocation. I've been using g++ 12 for development and I don't see that error.
#if __GNUC__ == 11
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Warray-bounds"
#endif
 
namespace swoc { inline namespace SWOC_VERSION_NS {
 
class TextView;

class CharSet {
  using self_type = CharSet;
 
public:
  constexpr CharSet(TextView const &chars);

  bool operator()(unsigned char c) const;

  bool operator()(char c) const;
 
protected:
  std::bitset<std::numeric_limits<unsigned char>::max() + 1> _chars;
};

class TextView : public std::string_view {
  using self_type  = TextView;         
  using super_type = std::string_view; 
 
public:
  constexpr TextView() noexcept = default;

  constexpr TextView(super_type const &that) noexcept;

  constexpr TextView(char const *ptr, size_t n) noexcept;

  constexpr TextView(char const *ptr, unsigned n) noexcept;

  constexpr TextView(char const *ptr, ssize_t n) noexcept;

  constexpr TextView(char const *ptr, int n) noexcept;

  template <typename T>
  explicit TextView(
    T first,
    std::enable_if_t<!std::is_array_v<T> && std::is_pointer_v<T> && std::is_convertible_v<T, char const *>, T> last) noexcept
    : super_type(first, last - first) {}

  template <typename C, typename = std::enable_if_t<std::is_convertible_v<decltype(std::declval<C>().data()), char const *> &&
                                                      std::is_convertible_v<decltype(std::declval<C>().size()), size_t>,
                                                    void>>
  constexpr TextView(C const &c);

  template <size_t N> constexpr TextView(const char (&s)[N]) noexcept;

  TextView(char *&src) : super_type(src, src ? strlen(src) : 0) {}

  TextView(char const *&src) : super_type(src, src ? strlen(src) : 0) {}

  constexpr TextView(std::nullptr_t) noexcept;

  TextView(std::string const &str) noexcept;

  self_type &operator=(super_type const &that);

  template <size_t N> self_type &operator=(const char (&s)[N]);

  self_type &operator=(char *&s);
  self_type &operator=(char const *&s);

  self_type &operator=(const std::string &s);

  self_type &assign(char *&c_str);

  self_type &assign(char const *&c_str);

  self_type &assign(char const *ptr, size_t n);

  self_type &assign(char const *b, char const *e);

  self_type &assign(std::string const &s);

  template <size_t N> self_type &assign(const char (&s)[N]) noexcept;

  template <typename C, typename = std::enable_if_t<std::is_convertible_v<decltype(std::declval<C>().data()), char const *> &&
                                                      std::is_convertible_v<decltype(std::declval<C>().size()), size_t>,
                                                    void>>
  constexpr self_type &
  assign(C const &c) {
    return this->assign(c.data(), c.size());
  }

  constexpr char operator*() const;

  self_type &operator++();

  self_type operator++(int);

  self_type &operator+=(size_t n);

  constexpr bool operator!() const noexcept;

  explicit constexpr operator bool() const noexcept;

  self_type &clear();

  template <typename F> size_t find_if(F const &pred) const;
  template <typename F> size_t rfind_if(F const &pred) const;

  self_type &ltrim(char c);

  self_type &ltrim(CharSet const &delimiters);

  self_type &ltrim(std::string_view const &delimiters);

  self_type &ltrim(const char *delimiters);

  template <typename F> self_type &ltrim_if(F const &pred);

  self_type &rtrim(char c);

  self_type &rtrim(CharSet const &delimiters);

  self_type &rtrim(std::string_view const &delimiters);

  template <typename F> self_type &rtrim_if(F const &pred);

  self_type &trim(char c);

  self_type &trim(CharSet const &delimiters);

  self_type &trim(std::string_view const &delimiters);

  self_type &trim(const char *delimiters);

  template <typename F> self_type &trim_if(F const &pred);

  constexpr self_type prefix(size_t n) const noexcept;

  self_type prefix_at(char c) const;

  self_type prefix_at(std::string_view const &delimiters) const;

  template <typename F> self_type prefix_if(F const &pred) const;

  self_type &remove_prefix(size_t n);

  self_type &remove_suffix(size_t n);

  self_type &remove_prefix_at(char c);

  self_type &remove_prefix_at(std::string_view const &delimiters);

  template <typename F> self_type &remove_prefix_if(F const &pred);

  self_type split_prefix(size_t n);

  self_type split_prefix_at(char c);

  self_type split_prefix_at(std::string_view const &delimiters);

  template <typename F> self_type split_prefix_if(F const &pred);

  self_type take_prefix(size_t n);

  self_type take_prefix_at(char c);

  self_type take_prefix_at(std::string_view const &delimiters);

  template <typename F> self_type take_prefix_if(F const &pred);

  template <typename F> self_type clip_prefix_of(F const &pred);

  constexpr self_type suffix(size_t n) const noexcept;

  self_type suffix_at(char c) const;

  self_type suffix_at(std::string_view const &delimiters) const;

  template <typename F> self_type suffix_if(F const &pred) const;

  self_type &remove_suffix_at(char c);

  self_type &remove_suffix_at(std::string_view const &delimiters);

  template <typename F> self_type &remove_suffix_if(F const &pred);

  self_type split_suffix(size_t n);

  self_type split_suffix_at(char c);

  self_type split_suffix_at(std::string_view const &delimiters);

  template <typename F> self_type split_suffix_if(F const &pred);

  self_type take_suffix(size_t n);

  self_type take_suffix_at(char c);

  self_type take_suffix_at(std::string_view const &delimiters);

  template <typename F> self_type take_suffix_if(F const &pred);

  template <typename F> self_type clip_suffix_of(F const &pred);

  constexpr self_type substr(size_type pos = 0, size_type count = npos) const noexcept;

  bool starts_with(std::string_view const &prefix) const noexcept;

  bool starts_with(char const *prefix) const;

  bool starts_with(char c) const noexcept;

  bool starts_with_nocase(std::string_view const &prefix) const noexcept;

  bool starts_with_nocase(char const *prefix) const;

  bool starts_with_nocase(char c) const noexcept;

  bool ends_with(std::string_view const &suffix) const noexcept;

  bool ends_with(char const *suffix) const;

  bool ends_with(char c) const noexcept;

  bool ends_with_nocase(std::string_view const &suffix) const noexcept;

  bool ends_with_nocase(char const *suffix) const;

  bool ends_with_nocase(char c) const noexcept;
 
  // Functors for using this class in STL containers.
  struct LessThan {
    bool
    operator()(self_type const &lhs, self_type const &rhs) const noexcept {
      return -1 == strcmp(lhs, rhs);
    }
  };

  struct LessThanNoCase {
    bool
    operator()(self_type const &lhs, self_type const &rhs) const noexcept {
      return -1 == strcasecmp(lhs, rhs);
    }
  };

  struct CaselessEqual {
    bool
    operator()(self_type const &lhs, self_type const &rhs) const noexcept {
      return lhs.size() == rhs.size() && 0 == strcasecmp(lhs, rhs);
    }
  };

  constexpr value_type const *data() const noexcept;

  constexpr value_type const *data_end() const noexcept;

  template <typename Stream> Stream &stream_write(Stream &os, const TextView &b) const;

  // These methods are all overloads of other methods, defined in order to make the API more
  // convenient to use. Mostly these overload @c int for @c size_t so naked numbers work as expected.
  constexpr self_type prefix(int n) const noexcept;
  self_type take_suffix(int n);
  self_type split_prefix(int n);
  constexpr self_type suffix(int n) const noexcept;
  self_type split_suffix(int n);
 
protected:
  static void init_delimiter_set(std::string_view const &delimiters, std::bitset<256> &set);
};

extern const int8_t svtoi_convert[256];

intmax_t svtoi(TextView src, TextView *parsed = nullptr, int base = 0);

uintmax_t svtou(TextView src, TextView *parsed = nullptr, int base = 0);

template <int RADIX>
uintmax_t
svto_radix(TextView &src) {
  static_assert(1 <= RADIX && RADIX <= 36, "Radix must be in the range 2..36");
  static constexpr auto MAX            = std::numeric_limits<uintmax_t>::max();
  static constexpr auto OVERFLOW_LIMIT = MAX / RADIX;
  uintmax_t zret                       = 0;
  uintmax_t v;
  while (src.size() && ((v = swoc::svtoi_convert[uint8_t(*src)]) < RADIX)) {
    // Tweaked for performance - need to check range after @a RADIX multiply.
    ++src; // Update view iff the character is parsed.
    if (zret <= OVERFLOW_LIMIT && v <= (MAX - (zret *= RADIX)) ) {
      zret += v;
    } else {
      zret = MAX; // clamp to max - once set will always hit this case for subsequent input.
    }
  }
  return zret;
}

template <int N>
uintmax_t
svto_radix(TextView &&src) {
  return svto_radix<N>(src);
}

double svtod(TextView text, TextView *parsed = nullptr);
// ----------------------------------------------------------
// Inline implementations.
// Note: Why, you may ask, do I use @c TextView::self_type for return type instead of the
// simpler plain @c TextView ? Because otherwise Doxygen can't match up the declaration and
// definition and the reference documentation is messed up. Sigh.
 
inline constexpr CharSet::CharSet(TextView const &chars) {
  for (auto c : chars) {
    _chars[uint8_t(c)] = true;
  }
}
 
inline bool
CharSet::operator()(unsigned char c) const {
  return _chars[c];
}
 
inline bool
CharSet::operator()(char c) const {
  return _chars[uint8_t(c)];
}
 
// === TextView Implementation ===
// Doxygen doesn't match these up well due to various type and template issues.
// @internal If there is more than one overload for numeric types, it's easy to get ambiguity. The only
// fix, unfortunately, is lots of overloads to cover the ambiguous cases.
inline constexpr TextView::TextView(const char *ptr, size_t n) noexcept
  : super_type(ptr, n == npos ? (ptr ? ::strlen(ptr) : 0) : n) {}
inline constexpr TextView::TextView(const char *ptr, unsigned n) noexcept : super_type(ptr, size_t(n)) {}
inline constexpr TextView::TextView(const char *ptr, ssize_t n) noexcept
  : super_type(ptr, n < 0 ? (ptr ? ::strlen(ptr) : 0) : size_t(n)) {}
inline constexpr TextView::TextView(const char *ptr, int n) noexcept
  : super_type(ptr, n < 0 ? (ptr ? ::strlen(ptr) : 0) : size_t(n)) {}
inline constexpr TextView::TextView(std::nullptr_t) noexcept : super_type(nullptr, 0) {}
inline TextView::TextView(std::string const &str) noexcept : super_type(str) {}
inline constexpr TextView::TextView(super_type const &that) noexcept : super_type(that) {}
template <size_t N> constexpr TextView::TextView(const char (&s)[N]) noexcept : super_type(s, s[N - 1] ? N : N - 1) {}
template <typename C, typename> constexpr TextView::TextView(C const &c) : super_type(c.data(), c.size()) {}
 
inline void
TextView::init_delimiter_set(std::string_view const &delimiters, std::bitset<256> &set) {
  set.reset();
  for (char c : delimiters)
    set[static_cast<uint8_t>(c)] = true;
}
 
inline auto
TextView::clear() -> self_type & {
  new (this) self_type();
  return *this;
}
 
inline constexpr char
TextView::operator*() const {
  return this->empty() ? char(0) : *(this->data());
}
 
inline constexpr bool
TextView::operator!() const noexcept {
  return this->empty();
}
 
inline constexpr TextView::operator bool() const noexcept {
  return !this->empty();
}
 
inline auto
TextView::operator++() -> self_type & {
  this->remove_prefix(1);
  return *this;
}
 
inline auto
TextView::operator++(int) -> self_type {
  self_type zret{*this};
  this->remove_prefix(1);
  return zret;
}
 
inline auto
TextView::operator+=(size_t n) -> self_type & {
  this->remove_prefix(n);
  return *this;
}
 
template <size_t N>
inline auto
TextView::operator=(const char (&s)[N]) -> self_type & {
  return *this = self_type{s, s[N - 1] ? N : N - 1};
}
 
inline auto
TextView::operator=(super_type const &that) -> self_type & {
  this->super_type::operator=(that);
  return *this;
}
 
inline auto
TextView::operator=(char *&s) -> self_type & {
  this->super_type::operator=(s);
  return *this;
}
 
inline auto
TextView::operator=(char const *&s) -> self_type & {
  this->super_type::operator=(s);
  return *this;
}
 
inline auto
TextView::operator=(const std::string &s) -> self_type & {
  this->super_type::operator=(s);
  return *this;
}
 
inline auto
TextView::assign(char *&c_str) -> self_type & {
  return this->assign(c_str, strlen(c_str));
}
 
inline auto
TextView::assign(char const *&c_str) -> self_type & {
  return this->assign(c_str, strlen(c_str));
}
 
inline auto
TextView::assign(const std::string &s) -> self_type & {
  *this = super_type(s);
  return *this;
}
 
inline TextView &
TextView::assign(char const *ptr, size_t n) {
  *this = super_type(ptr, n == npos ? (ptr ? ::strlen(ptr) : 0) : n);
  return *this;
}
 
inline TextView &
TextView::assign(char const *b, char const *e) {
  *this = super_type(b, e - b);
  return *this;
}
 
template <size_t N>
inline auto
TextView::assign(char const (&s)[N]) noexcept -> self_type & {
  return *this = self_type{s, s[N - 1] ? N : N - 1};
}
 
inline constexpr auto
TextView::prefix(size_t n) const noexcept -> self_type {
  return {this->data(), std::min(n, this->size())};
}
 
inline constexpr TextView
TextView::prefix(int n) const noexcept {
  return {this->data(), std::min<size_t>(n, this->size())};
}
 
inline auto
TextView::prefix_at(char c) const -> self_type {
  self_type zret; // default to empty return.
  if (auto n = this->find(c); n != npos) {
    zret.assign(this->data(), n);
  }
  return zret;
}
 
inline TextView
TextView::prefix_at(std::string_view const &delimiters) const {
  self_type zret; // default to empty return.
  if (auto n = this->find_first_of(delimiters); n != npos) {
    zret.assign(this->data(), n);
  }
  return zret;
}
 
template <typename F>
auto
TextView::prefix_if(F const &pred) const -> self_type {
  self_type zret; // default to empty return.
  if (auto n = this->find_if(pred); n != npos) {
    zret.assign(this->data(), n);
  }
  return zret;
}
 
inline auto
TextView::remove_prefix(size_t n) -> self_type & {
  this->super_type::remove_prefix(std::min(n, this->size()));
  return *this;
}
 
inline TextView &
TextView::remove_prefix_at(char c) {
  if (auto n = this->find(c); n != npos) {
    this->super_type::remove_prefix(n + 1);
  }
  return *this;
}
 
inline auto
TextView::remove_prefix_at(std::string_view const &delimiters) -> self_type & {
  if (auto n = this->find_first_of(delimiters); n != npos) {
    this->super_type::remove_prefix(n + 1);
  }
  return *this;
}
 
template <typename F>
auto
TextView::remove_prefix_if(F const &pred) -> self_type & {
  if (auto n = this->find_if(pred); n != npos) {
    this->super_type::remove_prefix(n + 1);
  }
  return *this;
}
 
inline TextView
TextView::split_prefix(size_t n) {
  self_type zret; // default to empty return.
  if (n < this->size()) {
    zret = this->prefix(n);
    this->remove_prefix(std::min(n + 1, this->size()));
  }
  return zret;
}
 
inline TextView
TextView::split_prefix(int n) {
  return this->split_prefix(size_t(n));
}
 
inline TextView
TextView::split_prefix_at(char c) {
  return this->split_prefix(this->find(c));
}
 
inline TextView
TextView::split_prefix_at(std::string_view const &delimiters) {
  return this->split_prefix(this->find_first_of(delimiters));
}
 
template <typename F>
TextView::self_type
TextView::split_prefix_if(F const &pred) {
  return this->split_prefix(this->find_if(pred));
}
 
inline TextView
TextView::take_prefix(size_t n) {
  n              = std::min(n, this->size());
  self_type zret = this->prefix(n);
  this->remove_prefix(std::min(n + 1, this->size()));
  return zret;
}
 
inline TextView
TextView::take_prefix_at(char c) {
  return this->take_prefix(this->find(c));
}
 
inline TextView
TextView::take_prefix_at(std::string_view const &delimiters) {
  return this->take_prefix(this->find_first_of(delimiters));
}
 
template <typename F>
auto
TextView::take_prefix_if(F const &pred) -> self_type {
  return this->take_prefix(this->find_if(pred));
}
 
inline constexpr TextView
TextView::suffix(size_t n) const noexcept {
  n = std::min(n, this->size());
  return {this->data_end() - n, n};
}
 
inline constexpr TextView
TextView::suffix(int n) const noexcept {
  return this->suffix(size_t(n));
}
 
inline TextView
TextView::suffix_at(char c) const {
  self_type zret;
  if (auto n = this->rfind(c); n != npos && n + 1 < this->size()) {
    ++n;
    zret.assign(this->data() + n, this->size() - n);
  }
  return zret;
}
 
inline TextView
TextView::suffix_at(std::string_view const &delimiters) const {
  self_type zret;
  if (auto n = this->find_last_of(delimiters); n != npos) {
    ++n;
    zret.assign(this->data() + n, this->size() - n);
  }
  return zret;
}
 
template <typename F>
auto
TextView::suffix_if(F const &pred) const -> self_type {
  self_type zret;
  if (auto n = this->rfind_if(pred); n != npos) {
    ++n;
    zret.assign(this->data() + n, this->size() - n);
  }
  return zret;
}
 
inline auto
TextView::remove_suffix(size_t n) -> self_type & {
  this->super_type::remove_suffix(std::min(n, this->size()));
  return *this;
}
 
inline TextView &
TextView::remove_suffix_at(char c) {
  if (auto n = this->rfind(c); n != npos) {
    return this->remove_suffix(this->size() - n);
  }
  return this->clear();
}
 
inline TextView &
TextView::remove_suffix_at(std::string_view const &delimiters) {
  if (auto n = this->find_last_of(delimiters); n != npos) {
    return this->remove_suffix(this->size() - n);
  }
  return this->clear();
}
 
template <typename F>
TextView::self_type &
TextView::remove_suffix_if(F const &pred) {
  if (auto n = this->rfind_if(pred); n != npos) {
    return this->remove_suffix(this->size() - n);
  }
  return this->clear();
}
 
inline TextView
TextView::split_suffix(size_t n) {
  self_type zret;
  n    = std::min(n, this->size());
  zret = this->suffix(n);
  this->remove_suffix(n + 1);
  return zret;
}
 
inline auto
TextView::split_suffix(int n) -> self_type {
  return this->split_suffix(size_t(n));
}
 
inline TextView
TextView::split_suffix_at(char c) {
  auto idx = this->rfind(c);
  return npos == idx ? self_type{} : this->split_suffix(this->size() - (idx + 1));
}
 
inline auto
TextView::split_suffix_at(std::string_view const &delimiters) -> self_type {
  auto idx = this->find_last_of(delimiters);
  return npos == idx ? self_type{} : this->split_suffix(this->size() - (idx + 1));
}
 
template <typename F>
TextView::self_type
TextView::split_suffix_if(F const &pred) {
  return this->split_suffix(this->rfind_if(pred));
}
 
inline TextView
TextView::take_suffix(size_t n) {
  self_type zret{*this};
  *this = zret.split_prefix(n);
  return zret;
}
 
inline TextView
TextView::take_suffix(int n) {
  return this->take_suffix(size_t(n));
}
 
inline TextView
TextView::take_suffix_at(char c) {
  return this->take_suffix(this->rfind(c));
}
 
inline TextView
TextView::take_suffix_at(std::string_view const &delimiters) {
  return this->take_suffix(this->find_last_of(delimiters));
}
 
template <typename F>
TextView::self_type
TextView::take_suffix_if(F const &pred) {
  return this->take_suffix_at(this->rfind_if(pred));
}
 
template <typename F>
inline size_t
TextView::find_if(F const &pred) const {
  for (const char *spot = this->data(), *limit = this->data_end(); spot < limit; ++spot)
    if (pred(*spot))
      return spot - this->data();
  return npos;
}
 
template <typename F>
inline size_t
TextView::rfind_if(F const &pred) const {
  for (const char *spot = this->data_end(), *limit = this->data(); spot > limit;)
    if (pred(*--spot))
      return spot - this->data();
  return npos;
}
 
inline TextView &
TextView::ltrim(char c) {
  this->remove_prefix(this->find_first_not_of(c));
  return *this;
}
 
inline TextView &
TextView::rtrim(char c) {
  auto n = this->find_last_not_of(c);
  this->remove_suffix(this->size() - (n == npos ? 0 : n + 1));
  return *this;
}
 
inline TextView &
TextView::trim(char c) {
  return this->ltrim(c).rtrim(c);
}
 
inline TextView &
TextView::ltrim(CharSet const &delimiters) {
  const char *spot  = this->data();
  const char *limit = this->data_end();
 
  while (spot < limit && delimiters(*spot)) {
    ++spot;
  }
  this->remove_prefix(spot - this->data());
 
  return *this;
}
 
inline TextView &
TextView::ltrim(std::string_view const &delimiters) {
  return this->ltrim(CharSet(delimiters));
}
 
inline TextView &
TextView::ltrim(const char *delimiters) {
  return this->ltrim(CharSet(delimiters));
}
 
inline TextView &
TextView::rtrim(CharSet const &delimiters) {
  const char *spot  = this->data_end();
  const char *limit = this->data();
  while (limit < spot-- && delimiters(*spot)) {
  }
 
  this->remove_suffix(this->data_end() - (spot + 1));
  return *this;
}
 
inline TextView &
TextView::rtrim(std::string_view const &delimiters) {
  return this->rtrim(CharSet(delimiters));
}
 
inline TextView &
TextView::trim(CharSet const &delimiters) {
  const char *spot;
  const char *limit;
 
  // Do this explicitly, so we don't have to initialize the character set twice.
  for (spot = this->data(), limit = this->data_end(); spot < limit && delimiters(*spot); ++spot)
    ;
  this->remove_prefix(spot - this->data());
 
  spot  = this->data_end();
  limit = this->data();
  while (limit < spot-- && delimiters(*spot)) {
  }
  this->remove_suffix(this->data_end() - (spot + 1));
 
  return *this;
}
 
inline TextView &
TextView::trim(std::string_view const &delimiters) {
  return this->trim(CharSet(delimiters));
}
 
inline TextView &
TextView::trim(const char *delimiters) {
  return this->trim(CharSet(delimiters));
}
 
template <typename F>
TextView::self_type &
TextView::ltrim_if(F const &pred) {
  const char *spot;
  const char *limit;
  for (spot = this->data(), limit = this->data_end(); spot < limit && pred(*spot); ++spot)
    ;
  this->remove_prefix(spot - this->data());
  return *this;
}
 
template <typename F>
TextView::self_type &
TextView::rtrim_if(F const &pred) {
  const char *spot  = this->data_end();
  const char *limit = this->data();
  while (limit < spot-- && pred(*spot))
    ;
  this->remove_suffix(this->data_end() - (spot + 1));
  return *this;
}
 
template <typename F>
TextView::self_type &
TextView::trim_if(F const &pred) {
  return this->ltrim_if(pred).rtrim_if(pred);
}
 
constexpr inline auto
TextView::data() const noexcept -> value_type const * {
  return super_type::data();
}
 
constexpr inline auto
TextView::data_end() const noexcept -> value_type const * {
  return this->data() + this->size();
}
 
inline constexpr TextView
TextView::substr(size_type pos, size_type count) const noexcept {
  if (pos >= this->size()) {
    return {};
  }
  count = std::min(this->size() - pos, count);
  return {this->data() + pos, count};
}
 
inline bool
TextView::starts_with(std::string_view const &prefix) const noexcept {
  return this->size() >= prefix.size() && 0 == ::memcmp(this->data(), prefix.data(), prefix.size());
}
 
inline bool
TextView::starts_with(char const *prefix) const {
  return this->starts_with(super_type(prefix));
}
inline bool
TextView::starts_with_nocase(char const *prefix) const {
  return this->starts_with_nocase(super_type{prefix});
}
 
inline bool
TextView::starts_with(char c) const noexcept {
  return !this->empty() && c == this->front();
}
inline bool
TextView::starts_with_nocase(char c) const noexcept {
  return !this->empty() && tolower(c) == tolower(this->front());
}
 
inline bool
TextView::starts_with_nocase(std::string_view const &prefix) const noexcept {
  return this->size() >= prefix.size() && 0 == ::strncasecmp(this->data(), prefix.data(), prefix.size());
}
 
inline bool
TextView::ends_with(std::string_view const &suffix) const noexcept {
  return this->size() >= suffix.size() && 0 == ::memcmp(this->data_end() - suffix.size(), suffix.data(), suffix.size());
}
 
inline bool
TextView::ends_with_nocase(std::string_view const &suffix) const noexcept {
  return this->size() >= suffix.size() && 0 == ::strncasecmp(this->data_end() - suffix.size(), suffix.data(), suffix.size());
}
 
inline bool
TextView::ends_with(char const *suffix) const {
  return this->ends_with(super_type(suffix));
}
 
inline bool
TextView::ends_with_nocase(char const *suffix) const {
  return this->ends_with_nocase(super_type(suffix));
}
 
inline bool
TextView::ends_with(char c) const noexcept {
  return !this->empty() && c == this->back();
}
inline bool
TextView::ends_with_nocase(char c) const noexcept {
  return !this->empty() && tolower(c) == tolower(this->back());
}
 
template <typename Stream>
Stream &
TextView::stream_write(Stream &os, const TextView &b) const {
  // Local function, avoids extra template work.
  static const auto stream_fill = [](Stream &ostream, size_t n) -> Stream & {
    static constexpr size_t pad_size = 8;
    typename Stream::char_type padding[pad_size];
 
    std::fill_n(padding, pad_size, ostream.fill());
    for (; n >= pad_size && ostream.good(); n -= pad_size)
      ostream.write(padding, pad_size);
    if (n > 0 && ostream.good())
      ostream.write(padding, n);
    return ostream;
  };
 
  const std::size_t w = os.width();
  if (w <= b.size()) {
    os.write(b.data(), b.size());
  } else {
    const std::size_t pad_size = w - b.size();
    const bool align_left      = (os.flags() & Stream::adjustfield) == Stream::left;
    if (!align_left && os.good())
      stream_fill(os, pad_size);
    if (os.good())
      os.write(b.data(), b.size());
    if (align_left && os.good())
      stream_fill(os, pad_size);
  }
  return os;
}
 
template <typename F>
TextView::self_type
TextView::clip_prefix_of(F const &pred) {
  size_t idx = 0;
  for (auto spot = this->data(), limit = spot + this->size(); spot < limit && pred(*spot); ++spot, ++idx)
    ; // empty
  TextView token = this->prefix(idx);
  this->remove_prefix(idx);
  return token;
}
 
template <typename F>
TextView::self_type
TextView::clip_suffix_of(F const &pred) {
  size_t idx = this->size() - 1;
  for (auto spot = this->data() + idx, limit = this->data(); spot >= limit && pred(*spot); --spot, --idx)
    ; // empty
  TextView token = this->suffix(idx);
  this->remove_suffix(idx);
  return token;
}
 
// Provide an instantiation for @c std::ostream as it's likely this is the only one ever used.
extern template std::ostream &TextView::stream_write(std::ostream &, const TextView &) const;

template <typename X, typename V> class TransformView {
  using self_type       = TransformView; 
  using source_iterator = decltype(V{}.begin());
 
public:
  using transform_type    = X; 
  using source_view_type  = V; 
  using source_value_type = std::remove_reference_t<decltype(*source_iterator{})>;
  using value_type = std::invoke_result_t<transform_type, source_value_type>;
  using iterator = self_type;

  TransformView(transform_type &&xf, source_view_type const &v);

  TransformView(transform_type const &xf, source_view_type const &v);

  TransformView(self_type const &that) = default;
  TransformView(self_type &&that) = default;

  self_type &operator=(self_type const &that) = default;
  self_type &operator=(self_type &&that) = default;

  bool operator==(self_type const &that) const;
  bool operator!=(self_type const &that) const;

  value_type operator*() const;
  self_type &operator++();
  self_type operator++(int);

  bool empty() const;
  explicit operator bool() const;

  iterator
  begin() const {
    return *this;
  }

  iterator
  end() const {
    return self_type{_xf, _limit};
  }
 
protected:
  transform_type _xf;     
  source_iterator _spot;  
  source_iterator _limit; 

  TransformView(transform_type &&xf, source_iterator &&limit) : _xf(xf), _spot(limit), _limit(limit) {}
};
 
template <typename X, typename V>
TransformView<X, V>::TransformView(transform_type &&xf, source_view_type const &v) : _xf(xf), _spot(v.begin()), _limit(v.end()) {}
 
template <typename X, typename V>
TransformView<X, V>::TransformView(transform_type const &xf, source_view_type const &v)
  : _xf(xf), _spot(v.begin()), _limit(v.end()) {}
 
template <typename X, typename V>
auto
TransformView<X, V>::operator*() const -> value_type {
  return _xf(*_spot);
}
 
template <typename X, typename V>
auto
TransformView<X, V>::operator++() -> self_type & {
  ++_spot;
  return *this;
}
 
template <typename X, typename V>
auto
TransformView<X, V>::operator++(int) -> self_type {
  self_type zret{*this};
  ++_spot;
  return zret;
}
 
template <typename X, typename V>
bool
TransformView<X, V>::empty() const {
  return _spot == _limit;
}
 
template <typename X, typename V> TransformView<X, V>::operator bool() const {
  return _spot != _limit;
}
 
template <typename X, typename V>
bool
TransformView<X, V>::operator==(self_type const &that) const {
  return _spot == that._spot && _limit == that._limit;
}
 
template <typename X, typename V>
bool
TransformView<X, V>::operator!=(self_type const &that) const {
  return _spot != that._spot || _limit != that._limit;
}

template <typename X, typename V>
TransformView<X, V>
transform_view_of(X const &xf, V const &src) {
  return TransformView<X, V>(xf, src);
}

template <typename V> class TransformView<void, V> {
  using self_type = TransformView; 
  using source_iterator = decltype(V{}.begin());
 
public:
  using source_view_type  = V; 
  using source_value_type = std::remove_reference_t<decltype(*source_iterator{})>;
  using value_type = source_value_type;
  using iterator = self_type;

  TransformView(source_view_type const &v) : _spot(v.begin()), _limit(v.end()) {}

  TransformView(self_type const &that) = default;
  TransformView(self_type &&that) = default;

  self_type &operator=(self_type const &that) = default;
  self_type &operator=(self_type &&that) = default;

  bool operator==(self_type const &that) const;
  bool operator!=(self_type const &that) const;

  value_type operator*() const;

  self_type &operator++();

  self_type operator++(int);

  bool empty() const;

  explicit operator bool() const;

  iterator begin() const;
  iterator end() const;
 
protected:
  source_iterator _spot;  
  source_iterator _limit; 

  explicit TransformView(source_iterator &&limit) : _spot(limit), _limit(limit) {}
};
 
template <typename V>
auto
TransformView<void, V>::operator*() const -> value_type {
  return *_spot;
}
 
template <typename V>
auto
TransformView<void, V>::operator++() -> self_type & {
  ++_spot;
  return *this;
}
 
template <typename V>
auto
TransformView<void, V>::operator++(int) -> self_type {
  auto zret{*this};
  ++*this;
  return zret;
}
 
template <typename V>
bool
TransformView<void, V>::operator==(const self_type &that) const {
  return _spot == that._spot && _limit == that._limit;
}
 
template <typename V>
bool
TransformView<void, V>::operator!=(const self_type &that) const {
  return _spot != that._spot || _limit != that._limit;
}
 
template <typename V>
bool
TransformView<void, V>::empty() const {
  return _spot == _limit;
}
 
template <typename V> TransformView<void, V>::operator bool() const {
  return _spot != _limit;
}
 
template <typename V>
auto
TransformView<void, V>::begin() const -> self_type {
  return *this;
}
 
template <typename V>
auto
TransformView<void, V>::end() const -> self_type {
  return self_type{_limit};
}

// Capture @c void transforms and make them identity transforms.
template <typename V>
TransformView<void, V>
transform_view_of(V const &v) {
  return TransformView<void, V>(v);
}


namespace literals {
constexpr std::string_view
operator"" _sv(const char *s, size_t n) {
  return {s, n};
}

constexpr swoc::TextView
operator"" _tv(const char *s, size_t n) {
  return {s, n};
}
} // namespace literals
 
}} // namespace swoc::SWOC_VERSION_NS
 
namespace std {
ostream &operator<<(ostream &os, const swoc::TextView &view);

/* For interaction with specific STL interfaces, primarily std::filesystem. Along with the
 * dereference operator, this enables a @c TextView to act as a character iterator to a C string
 * even if the internal view is not nul terminated.
 * @note Putting these directly in the class doesn't seem to work.
 */
template <> struct iterator_traits<swoc::TextView> {
  using value_type        = char;
  using pointer_type      = const char *;
  using reference_type    = const char &;
  using difference_type   = ssize_t;
  using iterator_category = forward_iterator_tag;
};
 
template <typename X, typename V> struct iterator_traits<swoc::TransformView<X, V>> {
  using value_type        = typename swoc::TransformView<X, V>::value_type;
  using pointer_type      = const value_type *;
  using reference_type    = const value_type &;
  using difference_type   = ssize_t;
  using iterator_category = forward_iterator_tag;
};
 
template <> struct hash<swoc::TextView> {
  static constexpr hash<string_view> super_hash{};
  size_t
  operator()(swoc::TextView const &s) const {
    return super_hash(s);
  }
};
 
} // namespace std
 
#if __GNUC__ == 11
#pragma GCC diagnostic pop
#endif