StringView.h

Go to the documentation of this file.

#pragma once
 
#include "HashFunctions.h"
#include "StringViewFormat.h"
 
#include "Collections/SmallVector.h"
 
#include <string>
#include <cstdio>
#include <vector>
 
namespace Cogs
{
  class COGSFOUNDATION_API StringView
  {
    using traits_type = std::char_traits<char>;
  public:
    using iterator = const char *;
 
    using const_iterator = const char *;
 
    using value_type = char;
 
    using Vector = Cogs::Collections::SmallVector<StringView, 10>;
 
    static constexpr size_t npos = static_cast<size_t>(-1);
 
    static constexpr size_t NoPosition = npos;
 
    constexpr StringView() noexcept = default;
 
    constexpr StringView(const char * data) noexcept
      : str(data), strSize(data ? traits_type::length(data) : 0)
    {
    }
 
    template<size_t LENGTH>
    constexpr StringView(const char (&data)[LENGTH]) noexcept : str(data), strSize(data ? traits_type::length(data) : 0) {
    }
 
    constexpr StringView(const char * data, const size_t length) noexcept : str(data), strSize(length) {}
 
    constexpr StringView(const std::string_view s) noexcept : str(s.data()), strSize(s.length()) {}
 
    StringView(const std::string & s) noexcept;
 
    bool operator==(const StringView & other) const { return strSize == other.strSize && compareMemory(str, other.str, other.strSize) == 0; }
 
    constexpr iterator begin() noexcept { return str; }
 
    constexpr iterator end() noexcept { return str + strSize; }
 
    constexpr const_iterator begin() const noexcept { return str; }
 
    constexpr const_iterator end() const noexcept { return str + strSize; }
 
    constexpr const_iterator cbegin() const noexcept { return str; }
 
    constexpr const_iterator cend() const noexcept { return str + strSize; }
 
    constexpr bool empty() const noexcept { return strSize == 0; }
 
    constexpr explicit operator bool() const noexcept { return strSize != 0; }
 
    explicit operator std::string() const { return to_string(); }
 
    constexpr operator std::string_view() const noexcept { return to_string_view(); }
 
    std::string to_string() const;
 
    constexpr std::string_view to_string_view() const noexcept { return std::string_view(str, strSize); }
 
    constexpr const char * data() const noexcept { return str; }
 
    constexpr size_t size() const noexcept { return strSize; }
    
    constexpr size_t length() const noexcept { return strSize; }
 
    constexpr char operator[](const size_t index) const noexcept { return data()[index]; }
 
    [[nodiscard]]
    constexpr size_t hash() const noexcept { return Cogs::hash(*this); }
 
    [[nodiscard]]
    constexpr size_t hash(size_t hashValue) const noexcept { return Cogs::hash(*this, hashValue); }
 
    [[nodiscard]]
    size_t hashLowercase(size_t hashValue = Cogs::hash()) const noexcept;
 
    size_t find(const StringView & other, size_t offset = 0) const noexcept;
 
    size_t find_first_of(char character, size_t pos = 0) const noexcept;
 
    size_t find_last_of(const StringView characters, size_t pos = NoPosition) const noexcept;
 
    size_t find_last_of(const char character, size_t pos = NoPosition) const noexcept;
 
    int compare(const StringView & other) const noexcept;
 
    constexpr StringView substr(size_t offset, size_t count = NoPosition) const noexcept
    {
      if (offset >= size()) return StringView();
 
      if (count == NoPosition) {
        return StringView(data() + offset, size() - offset);
      }
 
      return StringView(data() + offset, count < (size() - offset) ? count : size() - offset);
    }
 
    Vector split(const StringView& delimiters) const;
 
    Vector splitAll(const StringView& delimiters) const;
 
    StringView& trimStart() noexcept;
 
    StringView& trimEnd() noexcept;
 
    StringView& trim() noexcept;
 
  private:
    int compareMemory(const char * a, const char * b, size_t length) const { return ::memcmp(a, b, length); }
 
    const char * str = nullptr;
 
    size_t strSize = 0;
 
    static bool isWhiteSpace(char c) {
      return ((c == '\t') || (c == '\n') || (c == '\r') || (c == ' '));
    }
  };
 
  inline bool operator<(const StringView & left, const StringView & right) noexcept
  {
    return left.compare(right) < 0;
  }
 
  inline bool operator>(const StringView & left, const StringView & right) noexcept
  {
    return right < left;
  }
 
  inline bool operator<=(const StringView & left, const StringView & right) noexcept
  {
    return (!(right < left));
  }
 
  inline bool operator>=(const StringView & left, const StringView & right) noexcept
  {
    return (!(left < right));
  }
 
  inline bool operator==(const char * left, const StringView & right) noexcept
  {
    return StringView(left) == right;
  }
 
  inline bool operator==(const StringView & left, const char * right) noexcept
  {
    return left == StringView(right);
  }
 
  inline bool operator==(const std::string & left, const StringView & right) noexcept
  {
    return StringView(left) == right;
  }
 
  inline bool operator==(const std::string_view& left, const StringView& right) noexcept
  {
    return left == std::string_view(right);
  }
}