strings_internal.h

/*
 * 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 <http://www.gnu.org/licenses/>.
 */
 
#ifndef STRINGS_INTERNAL_H
#define STRINGS_INTERNAL_H
 
#include "strings_func.h"
#include "string_func.h"
 
struct StringParameter {
  StringParameterData data; 
  char32_t type; 
};
 
class StringParameters {
protected:
  StringParameters *parent = nullptr; 
  std::span<StringParameter> parameters = {}; 
 
  size_t offset = 0; 
  char32_t next_type = 0; 
 
  StringParameters(std::span<StringParameter> parameters = {}) :
    parameters(parameters)
  {}
 
  const StringParameter &GetNextParameterReference();
 
public:
  StringParameters(StringParameters &parent, size_t size) :
    parent(&parent),
    parameters(parent.parameters.subspan(parent.offset, size))
  {}
 
  void PrepareForNextRun();
  void SetTypeOfNextParameter(char32_t type) { this->next_type = type; }
 
  size_t GetOffset() { return this->offset; }
 
  void SetOffset(size_t offset)
  {
    /*
     * The offset must be fewer than the number of parameters when it is
     * being set. Unless restoring a backup, then the original value is
     * correct as well as long as the offset was not changed. In other
     * words, when the offset was already at the end of the parameters and
     * the string did not consume any parameters.
     */
    assert(offset < this->parameters.size() || this->offset == offset);
    this->offset = offset;
  }
 
  void AdvanceOffset(size_t advance)
  {
    this->offset += advance;
    assert(this->offset <= this->parameters.size());
  }
 
  template <typename T>
  T GetNextParameter()
  {
    struct visitor {
      uint64_t operator()(const uint64_t &arg) { return arg; }
      uint64_t operator()(const std::string &) { throw std::out_of_range("Attempt to read string parameter as integer"); }
    };
 
    const auto &param = GetNextParameterReference();
    return static_cast<T>(std::visit(visitor{}, param.data));
  }
 
  const char *GetNextParameterString()
  {
    struct visitor {
      const char *operator()(const uint64_t &) { throw std::out_of_range("Attempt to read integer parameter as string"); }
      const char *operator()(const std::string &arg) { return arg.c_str(); }
    };
 
    const auto &param = GetNextParameterReference();
    return std::visit(visitor{}, param.data);
  }
 
  StringParameters GetRemainingParameters() { return GetRemainingParameters(this->offset); }
 
  StringParameters GetRemainingParameters(size_t offset)
  {
    return StringParameters(this->parameters.subspan(offset, this->parameters.size() - offset));
  }
 
  size_t GetDataLeft() const
  {
    return this->parameters.size() - this->offset;
  }
 
  char32_t GetTypeAtOffset(size_t offset) const
  {
    assert(offset < this->parameters.size());
    return this->parameters[offset].type;
  }
 
  void SetParam(size_t n, const StringParameterData &v)
  {
    assert(n < this->parameters.size());
    this->parameters[n].data = v;
  }
 
  void SetParam(size_t n, uint64_t v)
  {
    assert(n < this->parameters.size());
    this->parameters[n].data = v;
  }
 
  template <typename T, std::enable_if_t<std::is_base_of<StrongTypedefBase, T>::value, int> = 0>
  void SetParam(size_t n, T v)
  {
    SetParam(n, v.base());
  }
 
  void SetParam(size_t n, const char *str)
  {
    assert(n < this->parameters.size());
    this->parameters[n].data = str;
  }
 
  void SetParam(size_t n, const std::string &str) { this->SetParam(n, str.c_str()); }
 
  void SetParam(size_t n, std::string &&str)
  {
    assert(n < this->parameters.size());
    this->parameters[n].data = std::move(str);
  }
 
  const StringParameterData &GetParam(size_t n) const
  {
    assert(n < this->parameters.size());
    return this->parameters[n].data;
  }
};
 
template <size_t N>
class ArrayStringParameters : public StringParameters {
  std::array<StringParameter, N> params{}; 
 
public:
  ArrayStringParameters()
  {
    this->parameters = std::span(params.data(), params.size());
  }
 
  ArrayStringParameters(ArrayStringParameters&& other) noexcept
  {
    *this = std::move(other);
  }
 
  ArrayStringParameters& operator=(ArrayStringParameters &&other) noexcept
  {
    this->offset = other.offset;
    this->next_type = other.next_type;
    this->params = std::move(other.params);
    this->parameters = std::span(params.data(), params.size());
    return *this;
  }
 
  ArrayStringParameters(const ArrayStringParameters &other) = delete;
  ArrayStringParameters& operator=(const ArrayStringParameters &other) = delete;
};
 
template <typename... Args>
static auto MakeParameters(const Args&... args)
{
  ArrayStringParameters<sizeof...(args)> parameters;
  size_t index = 0;
  (parameters.SetParam(index++, std::forward<const Args&>(args)), ...);
  return parameters;
}
 
class StringBuilder {
  std::string *string;
 
public:
  /* Required type for this to be an output_iterator; mimics std::back_insert_iterator. */
  using value_type = void;
  using difference_type = void;
  using iterator_category = std::output_iterator_tag;
  using pointer = void;
  using reference = void;
 
  StringBuilder(std::string &string) : string(&string) {}
 
  /* Required operators for this to be an output_iterator; mimics std::back_insert_iterator, which has no-ops. */
  StringBuilder &operator++() { return *this; }
  StringBuilder operator++(int) { return *this; }
  StringBuilder &operator*() { return *this; }
 
  StringBuilder &operator=(const char value)
  {
    return this->operator+=(value);
  }
 
  StringBuilder &operator+=(const char value)
  {
    this->string->push_back(value);
    return *this;
  }
 
  StringBuilder &operator+=(std::string_view str)
  {
    *this->string += str;
    return *this;
  }
 
  void Utf8Encode(char32_t c)
  {
    auto iterator = std::back_inserter(*this->string);
    ::Utf8Encode(iterator, c);
  }
 
  void RemoveElementsFromBack(size_t amount)
  {
    this->string->erase(this->string->size() - std::min(amount, this->string->size()));
  }
 
  size_t CurrentIndex()
  {
    return this->string->size();
  }
 
  char &operator[](size_t index)
  {
    return (*this->string)[index];
  }
};
 
void GetStringWithArgs(StringBuilder &builder, StringID string, StringParameters &args, uint case_index = 0, bool game_script = false);
std::string GetStringWithArgs(StringID string, StringParameters &args);
 
/* Do not leak the StringBuilder to everywhere. */
void GenerateTownNameString(StringBuilder &builder, size_t lang, uint32_t seed);
void GetTownName(StringBuilder &builder, const struct Town *t);
void GRFTownNameGenerate(StringBuilder &builder, uint32_t grfid, uint16_t gen, uint32_t seed);
 
uint RemapNewGRFStringControlCode(uint scc, const char **str, StringParameters &parameters, bool modify_parameters);
 
#endif /* STRINGS_INTERNAL_H */