string_consumer.hpp

Go to the documentation of this file.

/*
 * This file is part of OpenTTD.
 * OpenTTD is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, version 2.
 * OpenTTD is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
 * See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with OpenTTD. If not, see <https://www.gnu.org/licenses/old-licenses/gpl-2.0>.
 */

 
#ifndef STRING_CONSUMER_HPP
#define STRING_CONSUMER_HPP
 
#include <charconv>
#include "format.hpp"

class StringConsumer {
public:
  using size_type = std::string_view::size_type;

  static constexpr size_type npos = std::string_view::npos;

  static const std::string_view WHITESPACE_NO_NEWLINE;
  static const std::string_view WHITESPACE_OR_NEWLINE;
 
private:
  std::string_view src; 
  size_type position = 0; 
 
  static void LogError(std::string &&msg);
 
public:
  explicit StringConsumer(std::string_view src) : src(src) {}
  explicit StringConsumer(const std::string &src) : src(src) {}
  explicit StringConsumer(std::span<const char> src) : src(src.data(), src.size()) {}

  [[nodiscard]] bool AnyBytesLeft() const noexcept { return this->position < this->src.size(); }
  [[nodiscard]] size_type GetBytesLeft() const noexcept { return this->src.size() - this->position; }

  [[nodiscard]] bool AnyBytesRead() const noexcept { return this->position > 0; }
  [[nodiscard]] size_type GetBytesRead() const noexcept { return this->position; }

  [[nodiscard]] std::string_view GetOrigData() const noexcept { return this->src; }
  [[nodiscard]] std::string_view GetReadData() const noexcept { return this->src.substr(0, this->position); }
  [[nodiscard]] std::string_view GetLeftData() const noexcept { return this->src.substr(this->position); }

  void SkipAll() { this->position = this->src.size(); }

  [[nodiscard]] std::optional<uint8_t> PeekUint8() const;
  [[nodiscard]] std::optional<uint8_t> TryReadUint8()
  {
    auto value = this->PeekUint8();
    if (value.has_value()) this->SkipUint8();
    return value;
  }

  [[nodiscard]] uint8_t ReadUint8(uint8_t def = 0)
  {
    auto value = this->PeekUint8();
    this->SkipUint8(); // always advance
    return value.value_or(def);
  }

  void SkipUint8() { this->Skip(1); }

  [[nodiscard]] std::optional<int8_t> PeekSint8() const
  {
    auto result = PeekUint8();
    if (!result.has_value()) return std::nullopt;
    return static_cast<int8_t>(*result);
  }

  [[nodiscard]] std::optional<int8_t> TryReadSint8()
  {
    auto value = this->PeekSint8();
    if (value.has_value()) this->SkipSint8();
    return value;
  }

  [[nodiscard]] int8_t ReadSint8(int8_t def = 0)
  {
    auto value = this->PeekSint8();
    this->SkipSint8(); // always advance
    return value.value_or(def);
  }

  void SkipSint8() { this->Skip(1); }

  [[nodiscard]] std::optional<uint16_t> PeekUint16LE() const;
  [[nodiscard]] std::optional<uint16_t> TryReadUint16LE()
  {
    auto value = this->PeekUint16LE();
    if (value.has_value()) this->SkipUint16LE();
    return value;
  }

  [[nodiscard]] uint16_t ReadUint16LE(uint16_t def = 0)
  {
    auto value = this->PeekUint16LE();
    this->SkipUint16LE(); // always advance
    return value.value_or(def);
  }

  void SkipUint16LE() { this->Skip(2); }

  [[nodiscard]] std::optional<int16_t> PeekSint16LE() const
  {
    auto result = PeekUint16LE();
    if (!result.has_value()) return std::nullopt;
    return static_cast<int16_t>(*result);
  }

  [[nodiscard]] std::optional<int16_t> TryReadSint16LE()
  {
    auto value = this->PeekSint16LE();
    if (value.has_value()) this->SkipSint16LE();
    return value;
  }

  [[nodiscard]] int16_t ReadSint16LE(int16_t def = 0)
  {
    auto value = this->PeekSint16LE();
    this->SkipSint16LE(); // always advance
    return value.value_or(def);
  }

  void SkipSint16LE() { this->Skip(2); }

  [[nodiscard]] std::optional<uint32_t> PeekUint32LE() const;
  [[nodiscard]] std::optional<uint32_t> TryReadUint32LE()
  {
    auto value = this->PeekUint32LE();
    if (value.has_value()) this->SkipUint32LE();
    return value;
  }

  [[nodiscard]] uint32_t ReadUint32LE(uint32_t def = 0)
  {
    auto value = this->PeekUint32LE();
    this->SkipUint32LE(); // always advance
    return value.value_or(def);
  }

  void SkipUint32LE() { this->Skip(4); }

  [[nodiscard]] std::optional<int32_t> PeekSint32LE() const
  {
    auto result = PeekUint32LE();
    if (!result.has_value()) return std::nullopt;
    return static_cast<int32_t>(*result);
  }

  [[nodiscard]] std::optional<int32_t> TryReadSint32LE()
  {
    auto value = this->PeekSint32LE();
    if (value.has_value()) this->SkipSint32LE();
    return value;
  }

  [[nodiscard]] int32_t ReadSint32LE(int32_t def = 0)
  {
    auto value = this->PeekSint32LE();
    this->SkipSint32LE(); // always advance
    return value.value_or(def);
  }

  void SkipSint32LE() { this->Skip(4); }

  [[nodiscard]] std::optional<uint64_t> PeekUint64LE() const;
  [[nodiscard]] std::optional<uint64_t> TryReadUint64LE()
  {
    auto value = this->PeekUint64LE();
    if (value.has_value()) this->SkipUint64LE();
    return value;
  }

  [[nodiscard]] uint64_t ReadUint64LE(uint64_t def = 0)
  {
    auto value = this->PeekUint64LE();
    this->SkipUint64LE(); // always advance
    return value.value_or(def);
  }

  void SkipUint64LE() { this->Skip(8); }

  [[nodiscard]] std::optional<int64_t> PeekSint64LE() const
  {
    auto result = PeekUint64LE();
    if (!result.has_value()) return std::nullopt;
    return static_cast<int64_t>(*result);
  }

  [[nodiscard]] std::optional<int64_t> TryReadSint64LE()
  {
    auto value = this->PeekSint64LE();
    if (value.has_value()) this->SkipSint64LE();
    return value;
  }

  [[nodiscard]] int64_t ReadSint64LE(int64_t def = 0)
  {
    auto value = this->PeekSint64LE();
    this->SkipSint64LE(); // always advance
    return value.value_or(def);
  }

  void SkipSint64LE() { this->Skip(8); }

  [[nodiscard]] std::optional<char> PeekChar() const;
  [[nodiscard]] std::optional<char> TryReadChar()
  {
    auto value = this->PeekChar();
    if (value.has_value()) this->SkipChar();
    return value;
  }

  [[nodiscard]] char ReadChar(char def = '?') {
    auto value = this->PeekChar();
    this->SkipChar(); // always advance
    return value.value_or(def);
  }

  void SkipChar() { this->Skip(1); }

  [[nodiscard]] std::pair<size_type, char32_t> PeekUtf8() const;
  [[nodiscard]] std::optional<char32_t> TryReadUtf8()
  {
    auto [len, value] = this->PeekUtf8();
    if (len == 0) return std::nullopt;
    this->Skip(len);
    return value;
  }

  [[nodiscard]] char32_t ReadUtf8(char32_t def = '?')
  {
    auto [len, value] = this->PeekUtf8();
    this->Skip(len > 0 ? len : 1); // advance at least one byte
    return len > 0 ? value : def;
  }

  void SkipUtf8()
  {
    auto len = this->PeekUtf8().first;
    this->Skip(len > 0 ? len : 1); // advance at least one byte
  }

  [[nodiscard]] bool PeekIf(std::string_view str) const
  {
    return this->src.compare(this->position, str.size(), str) == 0;
  }

  [[nodiscard]] bool ReadIf(std::string_view str)
  {
    bool result = this->PeekIf(str);
    if (result) this->Skip(str.size());
    return result;
  }

  void SkipIf(std::string_view str)
  {
    if (this->PeekIf(str)) this->Skip(str.size());
  }

  [[nodiscard]] bool PeekCharIf(char c) const
  {
    return this->PeekIf({&c, 1});
  }

  [[nodiscard]] bool ReadCharIf(char c)
  {
    return this->ReadIf({&c, 1});
  }

  void SkipCharIf(char c)
  {
    return this->SkipIf({&c, 1});
  }

  [[nodiscard]] bool PeekUtf8If(char32_t c) const
  {
    auto [len, result] = this->PeekUtf8();
    return len > 0 && result == c;
  }

  [[nodiscard]] bool ReadUtf8If(char32_t c)
  {
    auto [len, result] = this->PeekUtf8();
    if (len == 0 || result != c) return false;
    this->Skip(len);
    return true;
  }

  void SkipUtf8If(char32_t c)
  {
    auto [len, result] = this->PeekUtf8();
    if (len > 0 && result == c) {
      this->Skip(len);
    }
  }

  [[nodiscard]] std::string_view Peek(size_type len) const;
  [[nodiscard]] std::string_view Read(size_type len)
  {
    auto result = this->Peek(len);
    if (len != npos && len != result.size()) {
      LogError(fmt::format("Source buffer too short: {} > {}", len, result.size()));
    }
    this->Skip(result.size());
    return result;
  }

  void Skip(size_type len);

  [[nodiscard]] size_type Find(std::string_view str) const;
  [[nodiscard]] size_type FindChar(char c) const
  {
    return this->Find({&c, 1});
  }

  [[nodiscard]] size_type FindUtf8(char32_t c) const;

  [[nodiscard]] size_type FindCharIn(std::string_view chars) const;
  [[nodiscard]] size_type FindCharNotIn(std::string_view chars) const;

  [[nodiscard]] std::optional<char> PeekCharIfIn(std::string_view chars) const
  {
    assert(!chars.empty());
    std::optional<char> c = this->PeekChar();
    if (c.has_value() && chars.find(*c) != std::string_view::npos) return c;
    return std::nullopt;
  }

  [[nodiscard]] std::optional<char> ReadCharIfIn(std::string_view chars)
  {
    auto result = this->PeekCharIfIn(chars);
    if (result.has_value()) this->Skip(1);
    return result;
  }

  void SkipCharIfIn(std::string_view chars)
  {
    auto result = this->PeekCharIfIn(chars);
    if (result.has_value()) this->Skip(1);
  }

  [[nodiscard]] std::optional<char> PeekCharIfNotIn(std::string_view chars) const
  {
    assert(!chars.empty());
    std::optional<char> c = this->PeekChar();
    if (c.has_value() && chars.find(*c) == std::string_view::npos) return c;
    return std::nullopt;
  }

  [[nodiscard]] std::optional<char> ReadCharIfNotIn(std::string_view chars)
  {
    auto result = this->PeekCharIfNotIn(chars);
    if (result.has_value()) this->Skip(1);
    return result;
  }

  void SkipCharIfNotIn(std::string_view chars)
  {
    auto result = this->PeekCharIfNotIn(chars);
    if (result.has_value()) this->Skip(1);
  }

  [[nodiscard]] std::string_view PeekUntilCharIn(std::string_view chars) const
  {
    size_type len = this->FindCharIn(chars);
    return this->Peek(len);
  }

  [[nodiscard]] std::string_view ReadUntilCharIn(std::string_view chars)
  {
    size_type len = this->FindCharIn(chars);
    return this->Read(len);
  }

  void SkipUntilCharIn(std::string_view chars)
  {
    size_type len = this->FindCharIn(chars);
    this->Skip(len);
  }

  [[nodiscard]] std::string_view PeekUntilCharNotIn(std::string_view chars) const
  {
    size_type len = this->FindCharNotIn(chars);
    return this->Peek(len);
  }

  [[nodiscard]] std::string_view ReadUntilCharNotIn(std::string_view chars)
  {
    size_type len = this->FindCharNotIn(chars);
    return this->Read(len);
  }

  void SkipUntilCharNotIn(std::string_view chars)
  {
    size_type len = this->FindCharNotIn(chars);
    this->Skip(len);
  }

  enum SeparatorUsage {
    READ_ALL_SEPARATORS, 
    READ_ONE_SEPARATOR,  
    KEEP_SEPARATOR,      
    SKIP_ONE_SEPARATOR,  
    SKIP_ALL_SEPARATORS, 
  };

  [[nodiscard]] std::string_view PeekUntil(std::string_view str, SeparatorUsage sep) const;
  [[nodiscard]] std::string_view ReadUntil(std::string_view str, SeparatorUsage sep)
  {
    assert(!str.empty());
    auto result = this->PeekUntil(str, sep);
    this->Skip(result.size());
    switch (sep) {
      default:
        break;
      case SKIP_ONE_SEPARATOR:
        this->SkipIf(str);
        break;
      case SKIP_ALL_SEPARATORS:
        while (this->ReadIf(str)) {}
        break;
    }
    return result;
  }

  void SkipUntil(std::string_view str, SeparatorUsage sep)
  {
    assert(!str.empty());
    this->Skip(this->Find(str));
    switch (sep) {
      default:
        break;
      case READ_ONE_SEPARATOR:
      case SKIP_ONE_SEPARATOR:
        this->SkipIf(str);
        break;
      case READ_ALL_SEPARATORS:
      case SKIP_ALL_SEPARATORS:
        while (this->ReadIf(str)) {}
        break;
    }
  }

  [[nodiscard]] std::string_view PeekUntilChar(char c, SeparatorUsage sep) const
  {
    return this->PeekUntil({&c, 1}, sep);
  }

  [[nodiscard]] std::string_view ReadUntilChar(char c, SeparatorUsage sep)
  {
    return this->ReadUntil({&c, 1}, sep);
  }

  void SkipUntilChar(char c, SeparatorUsage sep)
  {
    this->SkipUntil({&c, 1}, sep);
  }

  [[nodiscard]] std::string_view PeekUntilUtf8(char32_t c, SeparatorUsage sep) const;
  [[nodiscard]] std::string_view ReadUntilUtf8(char32_t c, SeparatorUsage sep);
  void SkipUntilUtf8(char32_t c, SeparatorUsage sep);
 
private:
  template <class T>
  [[nodiscard]] static std::pair<size_type, T> ParseIntegerBase(std::string_view src, int base, bool clamp, bool log_errors)
  {
    if (base == 0) {
      /* Try positive hex */
      if (src.starts_with("0x") || src.starts_with("0X")) {
        auto [len, value] = ParseIntegerBase<T>(src.substr(2), 16, clamp, log_errors);
        if (len == 0) return {};
        return {len + 2, value};
      }
 
      /* Try negative hex */
      if (std::is_signed_v<T> && (src.starts_with("-0x") || src.starts_with("-0X"))) {
        using Unsigned = std::make_unsigned_t<T>;
        auto [len, uvalue] = ParseIntegerBase<Unsigned>(src.substr(3), 16, clamp, log_errors);
        if (len == 0) return {};
        T value = static_cast<T>(0 - uvalue);
        if (value > 0) {
          if (!clamp) {
            if (log_errors) LogError(fmt::format("Integer out of range: '{}'", src.substr(0, len + 3)));
            return {};
          }
          value = std::numeric_limits<T>::lowest();
        }
        return {len + 3, value};
      }
 
      /* Try decimal */
      return ParseIntegerBase<T>(src, 10, clamp, log_errors);
    }
 
    T value{};
    assert(base == 8 || base == 10 || base == 16); // we only support these bases when skipping
    auto result = std::from_chars(src.data(), src.data() + src.size(), value, base);
    auto len = result.ptr - src.data();
    if (result.ec == std::errc::result_out_of_range) {
      if (!clamp) {
        if (log_errors) LogError(fmt::format("Integer out of range: '{}'+'{}'", src.substr(0, len), src.substr(len, 4)));
        return {};
      }
      if (src.starts_with("-")) {
        value = std::numeric_limits<T>::lowest();
      } else {
        value = std::numeric_limits<T>::max();
      }
    } else if (result.ec != std::errc{}) {
      if (log_errors) LogError(fmt::format("Cannot parse integer: '{}'+'{}'", src.substr(0, len), src.substr(len, 4)));
      return {};
    }
    return {len, value};
  }
 
public:
  template <class T>
  [[nodiscard]] std::pair<size_type, T> PeekIntegerBase(int base, bool clamp = false) const
  {
    return ParseIntegerBase<T>(this->src.substr(this->position), base, clamp, false);
  }

  template <class T>
  [[nodiscard]] std::optional<T> TryReadIntegerBase(int base, bool clamp = false)
  {
    auto [len, value] = this->PeekIntegerBase<T>(base, clamp);
    if (len == 0) return std::nullopt;
    this->SkipIntegerBase(base);
    return value;
  }

  template <class T>
  [[nodiscard]] T ReadIntegerBase(int base, T def = 0, bool clamp = false)
  {
    auto [len, value] = ParseIntegerBase<T>(this->src.substr(this->position), base, clamp, true);
    this->SkipIntegerBase(base); // always advance
    return len > 0 ? value : def;
  }

  void SkipIntegerBase(int base);
};

template <class T = uint32_t>
static inline std::optional<T> ParseInteger(std::string_view arg, int base = 10, bool clamp = false)
{
  StringConsumer consumer{arg};
  consumer.SkipUntilCharNotIn(StringConsumer::WHITESPACE_NO_NEWLINE);
  auto result = consumer.TryReadIntegerBase<T>(base, clamp);
  consumer.SkipUntilCharNotIn(StringConsumer::WHITESPACE_NO_NEWLINE);
  if (consumer.AnyBytesLeft()) return std::nullopt;
  return result;
}
 
#endif /* STRING_CONSUMER_HPP */