StringView.cpp

#include "StringView.h"
 
#include <algorithm>
 
Cogs::StringView::StringView(const std::string & s) noexcept
  : str(s.c_str()), strSize(s.length())
{}
 
std::string Cogs::StringView::to_string() const {
  return std::string(str, strSize);
}
 
size_t Cogs::StringView::hashLowercase(size_t hashValue) const noexcept
{
  return Cogs::hashLowercase(*this, hashValue);
}
 
size_t Cogs::StringView::find(const StringView & other, size_t offset) const noexcept
{
  if (other.size() > size() + offset) return NoPosition;
 
  auto found = std::search(begin()+offset, end(), other.begin(), other.end());
 
  if (found != end()) {
    return std::distance(begin(), found);
  }
 
  return NoPosition;
}
 
size_t Cogs::StringView::find_last_of(const StringView characters, size_t pos) const noexcept
{
  size_t N = length();
  if (pos < N) N = pos + 1;
 
  size_t k = NoPosition;
  for (size_t i = 0; i < N; i++) {
    auto ch = data()[i];
    for (size_t j = 0; j < characters.size(); j++) {
      if (characters[j] == ch) { k = i; }
    }
  }
  return k;
}
 
size_t Cogs::StringView::find_first_of(char character, size_t pos) const noexcept
{
  for (size_t len = length(); pos < len; ++pos) {
    if(data()[pos] == character) {
      return pos;
    }
  }
  return NoPosition;
}
 
size_t Cogs::StringView::find_last_of(const char character, size_t pos) const noexcept
{
  size_t N = length();
  if (pos < N) N = pos + 1;
 
  size_t k = NoPosition;
  for (size_t i = 0; i < N; i++) {
    if(data()[i] == character) { k = i; }
  }
  return k;
}
 
int Cogs::StringView::compare(const StringView & other) const noexcept
{
  const size_t lSize = size();
  const size_t rSize = other.size();
  const int result = compareMemory(str, other.str, std::min(lSize, rSize));
  if (result != 0) return result;
  if (lSize < rSize) return -1;
  if (lSize > rSize) return 1;
  return 0;
}
 
Cogs::StringView::Vector Cogs::StringView::split(const StringView& delimiters) const
{
  Vector        tokens;
  const char *  read = data();
  const char *  token = nullptr;
 
  for (const char * const end = read + size(); read != end; ++read) {
    const bool isSplitter = delimiters.find_first_of(*read) != NoPosition;
 
    if (!isSplitter && !token) {
      token = read;
    }
    else if (isSplitter && token) {
      tokens.push_back(StringView(token, read - token));
      token = nullptr;
    }
  }
  if (token) {
    tokens.push_back(StringView(token, read - token));
  }
  return tokens;
}
 
Cogs::StringView::Vector Cogs::StringView::splitAll(const StringView& delimiters) const
{
  Vector        tokens;
  const char *  read = data();
  const char *  token = read;
 
  for (const char * const end = read + size(); read != end; ++read) {
    if (delimiters.find_first_of(*read) != NoPosition) {
      tokens.push_back(StringView(token, read - token));
      token = read + 1;
    }
  }
  tokens.push_back(StringView(token, read - token));
  return tokens;
}
 
Cogs::StringView& Cogs::StringView::trimStart() noexcept
{
  while (strSize && isWhiteSpace(*str)) {
    str++;
    strSize--;
  }
  return *this;
}
 
Cogs::StringView& Cogs::StringView::trimEnd() noexcept
{
  while (strSize && isWhiteSpace(str[strSize - 1])) {
    strSize--;
  }
  return *this;
}
 
Cogs::StringView& Cogs::StringView::trim() noexcept
{
  return trimStart().trimEnd();
}