str.h

#pragma once
#include "gaia/config/config.h"
 
#include <cstdint>
#include <cstring>
 
#include "gaia/cnt/darray.h"
#include "gaia/core/span.h"
 
namespace gaia {
  namespace util {
    struct str_view {
      const char* m_data = nullptr;
      uint32_t m_size = 0;
 
      str_view() = default;
 
      constexpr str_view(const char* data, uint32_t size): m_data(data), m_size(size) {}
 
      template <size_t N>
      constexpr str_view(const char (&lit)[N]): m_data(lit), m_size((uint32_t)(N - 1)) {
        static_assert(N > 0);
      }
 
      GAIA_NODISCARD constexpr const char* data() const {
        return m_data;
      }
 
      GAIA_NODISCARD constexpr uint32_t size() const {
        return m_size;
      }
 
      GAIA_NODISCARD constexpr bool empty() const {
        return m_size == 0;
      }
 
      GAIA_NODISCARD constexpr uint32_t find(str_view value, uint32_t pos = 0) const {
        return find(value.data(), value.size(), pos);
      }
 
      GAIA_NODISCARD constexpr uint32_t find(const char* value, uint32_t len, uint32_t pos) const {
        if (pos > m_size)
          return BadIndex;
        if (len == 0)
          return pos;
        if (len > m_size - pos)
          return BadIndex;
 
        for (uint32_t i = pos; i + len <= m_size; ++i) {
          if (equal_bytes(m_data + i, value, len))
            return i;
        }
        return BadIndex;
      }
 
      template <size_t N>
      GAIA_NODISCARD constexpr uint32_t find(const char (&lit)[N], uint32_t pos = 0) const {
        static_assert(N > 0);
        return find(str_view(lit), pos);
      }
 
      GAIA_NODISCARD constexpr uint32_t find(char ch, uint32_t pos = 0) const {
        if (pos >= m_size)
          return BadIndex;
        for (uint32_t i = pos; i < m_size; ++i) {
          if (m_data[i] == ch)
            return i;
        }
        return BadIndex;
      }
 
      GAIA_NODISCARD constexpr uint32_t find_first_of(str_view chars, uint32_t pos = 0) const {
        if (pos >= m_size || chars.empty())
          return BadIndex;
        for (uint32_t i = pos; i < m_size; ++i) {
          if (contains(chars, m_data[i]))
            return i;
        }
        return BadIndex;
      }
 
      GAIA_NODISCARD constexpr uint32_t find_first_of(char ch, uint32_t pos = 0) const {
        return find(ch, pos);
      }
 
      template <size_t N>
      GAIA_NODISCARD constexpr uint32_t find_first_of(const char (&lit)[N], uint32_t pos = 0) const {
        return find_first_of(str_view(lit), pos);
      }
 
      GAIA_NODISCARD constexpr uint32_t find_last_of(str_view chars, uint32_t pos = BadIndex) const {
        if (m_size == 0 || chars.empty())
          return BadIndex;
 
        uint32_t i = pos;
        if (i == BadIndex || i >= m_size)
          i = m_size - 1;
 
        for (;;) {
          if (contains(chars, m_data[i]))
            return i;
          if (i == 0)
            break;
          --i;
        }
        return BadIndex;
      }
 
      GAIA_NODISCARD constexpr uint32_t find_last_of(char ch, uint32_t pos = BadIndex) const {
        if (m_size == 0)
          return BadIndex;
 
        uint32_t i = pos;
        if (i == BadIndex || i >= m_size)
          i = m_size - 1;
 
        for (;;) {
          if (m_data[i] == ch)
            return i;
          if (i == 0)
            break;
          --i;
        }
        return BadIndex;
      }
 
      template <size_t N>
      GAIA_NODISCARD constexpr uint32_t find_last_of(const char (&lit)[N], uint32_t pos = BadIndex) const {
        return find_last_of(str_view(lit), pos);
      }
 
      GAIA_NODISCARD constexpr uint32_t find_first_not_of(str_view chars, uint32_t pos = 0) const {
        if (pos >= m_size)
          return BadIndex;
        if (chars.empty())
          return pos;
 
        for (uint32_t i = pos; i < m_size; ++i) {
          if (!contains(chars, m_data[i]))
            return i;
        }
        return BadIndex;
      }
 
      GAIA_NODISCARD constexpr uint32_t find_first_not_of(char ch, uint32_t pos = 0) const {
        if (pos >= m_size)
          return BadIndex;
        for (uint32_t i = pos; i < m_size; ++i) {
          if (m_data[i] != ch)
            return i;
        }
        return BadIndex;
      }
 
      template <size_t N>
      GAIA_NODISCARD constexpr uint32_t find_first_not_of(const char (&lit)[N], uint32_t pos = 0) const {
        return find_first_not_of(str_view(lit), pos);
      }
 
      GAIA_NODISCARD constexpr uint32_t find_last_not_of(str_view chars, uint32_t pos = BadIndex) const {
        if (m_size == 0)
          return BadIndex;
 
        uint32_t i = pos;
        if (i == BadIndex || i >= m_size)
          i = m_size - 1;
 
        if (chars.empty())
          return i;
 
        for (;;) {
          if (!contains(chars, m_data[i]))
            return i;
          if (i == 0)
            break;
          --i;
        }
        return BadIndex;
      }
 
      GAIA_NODISCARD constexpr uint32_t find_last_not_of(char ch, uint32_t pos = BadIndex) const {
        if (m_size == 0)
          return BadIndex;
 
        uint32_t i = pos;
        if (i == BadIndex || i >= m_size)
          i = m_size - 1;
 
        for (;;) {
          if (m_data[i] != ch)
            return i;
          if (i == 0)
            break;
          --i;
        }
        return BadIndex;
      }
 
      template <size_t N>
      GAIA_NODISCARD constexpr uint32_t find_last_not_of(const char (&lit)[N], uint32_t pos = BadIndex) const {
        return find_last_not_of(str_view(lit), pos);
      }
 
      template <size_t N>
      GAIA_NODISCARD constexpr bool operator==(const char (&lit)[N]) const {
        static_assert(N > 0);
        return m_size == (uint32_t)(N - 1) && equal_bytes(m_data, lit, m_size);
      }
 
      GAIA_NODISCARD constexpr bool operator==(str_view other) const {
        return m_size == other.m_size && equal_bytes(m_data, other.m_data, m_size);
      }
 
      GAIA_NODISCARD constexpr bool operator!=(str_view other) const {
        return !operator==(other);
      }
 
    private:
      GAIA_NODISCARD static constexpr bool contains(str_view set, char value) {
        for (uint32_t i = 0; i < set.m_size; ++i) {
          if (set.m_data[i] == value)
            return true;
        }
        return false;
      }
 
      GAIA_NODISCARD static constexpr bool equal_bytes(const char* left, const char* right, uint32_t size) {
        for (uint32_t i = 0; i < size; ++i) {
          if (left[i] != right[i])
            return false;
        }
        return true;
      }
    };
 
    struct str {
      cnt::darray<char> m_data;
 
      str() = default;
 
      explicit str(str_view view) {
        assign(view);
      }
 
      template <size_t N>
      explicit str(const char (&lit)[N]) {
        assign(lit);
      }
 
      void clear() {
        m_data.clear();
      }
 
      void reserve(uint32_t len) {
        m_data.reserve(len);
      }
 
      void assign(const char* data, uint32_t size) {
        m_data.resize(size);
        if (size > 0)
          memcpy(m_data.data(), data, size);
      }
 
      void assign(str_view view) {
        assign(view.data(), view.size());
      }
 
      template <size_t N>
      void assign(const char (&lit)[N]) {
        static_assert(N > 0);
        assign(lit, (uint32_t)(N - 1));
      }
 
      void append(const char* data, uint32_t size) {
        const auto oldSize = this->size();
        // The length is 32-bit. A wrapping sum would shrink the buffer right before the copy.
        GAIA_ASSERT(size <= (uint32_t)-1 - oldSize);
        if (size == 0 || size > (uint32_t)-1 - oldSize)
          return;
 
        m_data.resize(oldSize + size, cnt::ResizePolicy::Scale);
        memcpy(m_data.data() + oldSize, data, size);
      }
 
      void append(str_view view) {
        append(view.data(), view.size());
      }
 
      template <size_t N>
      void append(const char (&lit)[N]) {
        static_assert(N > 0);
        append(lit, (uint32_t)(N - 1));
      }
 
      void append(char ch) {
        m_data.push_back(ch);
      }
 
      GAIA_NODISCARD const char* data() const {
        return m_data.data();
      }
 
      GAIA_NODISCARD char* data() {
        return m_data.data();
      }
 
      GAIA_NODISCARD uint32_t size() const {
        return (uint32_t)m_data.size();
      }
 
      GAIA_NODISCARD bool empty() const {
        return m_data.empty();
      }
 
      GAIA_NODISCARD str_view view() const {
        return str_view(data(), size());
      }
 
      GAIA_NODISCARD operator str_view() const {
        return view();
      }
 
      template <size_t N>
      GAIA_NODISCARD bool operator==(const char (&lit)[N]) const {
        static_assert(N > 0);
        const auto len = (uint32_t)(N - 1);
        return size() == len && (len == 0 || memcmp(data(), lit, len) == 0);
      }
 
      GAIA_NODISCARD bool operator==(str_view other) const {
        return size() == other.size() && (size() == 0 || memcmp(data(), other.data(), size()) == 0);
      }
 
      GAIA_NODISCARD bool operator==(const str& other) const {
        return operator==(other.view());
      }
 
      GAIA_NODISCARD uint32_t find(str_view value, uint32_t pos = 0) const {
        return view().find(value, pos);
      }
 
      GAIA_NODISCARD uint32_t find(const char* value, uint32_t len, uint32_t pos) const {
        return view().find(value, len, pos);
      }
 
      template <size_t N>
      GAIA_NODISCARD uint32_t find(const char (&lit)[N], uint32_t pos = 0) const {
        static_assert(N > 0);
        return find(str_view(lit), pos);
      }
 
      GAIA_NODISCARD uint32_t find(char ch, uint32_t pos = 0) const {
        return view().find(ch, pos);
      }
 
      GAIA_NODISCARD uint32_t find_first_of(str_view chars, uint32_t pos = 0) const {
        return view().find_first_of(chars, pos);
      }
 
      GAIA_NODISCARD uint32_t find_first_of(char ch, uint32_t pos = 0) const {
        return view().find_first_of(ch, pos);
      }
 
      template <size_t N>
      GAIA_NODISCARD uint32_t find_first_of(const char (&lit)[N], uint32_t pos = 0) const {
        return view().find_first_of(lit, pos);
      }
 
      GAIA_NODISCARD uint32_t find_last_of(str_view chars, uint32_t pos = BadIndex) const {
        return view().find_last_of(chars, pos);
      }
 
      GAIA_NODISCARD uint32_t find_last_of(char ch, uint32_t pos = BadIndex) const {
        return view().find_last_of(ch, pos);
      }
 
      template <size_t N>
      GAIA_NODISCARD uint32_t find_last_of(const char (&lit)[N], uint32_t pos = BadIndex) const {
        return view().find_last_of(lit, pos);
      }
 
      GAIA_NODISCARD uint32_t find_first_not_of(str_view chars, uint32_t pos = 0) const {
        return view().find_first_not_of(chars, pos);
      }
 
      GAIA_NODISCARD uint32_t find_first_not_of(char ch, uint32_t pos = 0) const {
        return view().find_first_not_of(ch, pos);
      }
 
      template <size_t N>
      GAIA_NODISCARD uint32_t find_first_not_of(const char (&lit)[N], uint32_t pos = 0) const {
        return view().find_first_not_of(lit, pos);
      }
 
      GAIA_NODISCARD uint32_t find_last_not_of(str_view chars, uint32_t pos = BadIndex) const {
        return view().find_last_not_of(chars, pos);
      }
 
      GAIA_NODISCARD uint32_t find_last_not_of(char ch, uint32_t pos = BadIndex) const {
        return view().find_last_not_of(ch, pos);
      }
 
      template <size_t N>
      GAIA_NODISCARD uint32_t find_last_not_of(const char (&lit)[N], uint32_t pos = BadIndex) const {
        return view().find_last_not_of(lit, pos);
      }
    };
 
    GAIA_NODISCARD constexpr bool is_whitespace(char c) {
      return c == ' ' || (c >= '\t' && c <= '\r');
    }
 
    GAIA_NODISCARD constexpr str_view trim(str_view expr) {
      const auto len = expr.size();
      if (len == 0)
        return {};
 
      uint32_t beg = 0;
      while (beg < len && is_whitespace(expr.data()[beg]))
        ++beg;
      if (beg == len)
        return {};
 
      uint32_t end = len - 1;
      while (end > beg && is_whitespace(expr.data()[end]))
        --end;
      return str_view(expr.data() + beg, end - beg + 1);
    }
 
    GAIA_NODISCARD constexpr std::span<const char> trim(std::span<const char> expr) {
      const auto trimmed = trim(str_view(expr.data(), (uint32_t)expr.size()));
      return std::span<const char>(trimmed.data(), trimmed.size());
    }
  } // namespace util
} // namespace gaia