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"
#include "core/string_builder.hpp"
#include "core/string_consumer.hpp"
 
class StringParameters {
protected:
  StringParameters *parent = nullptr; 
  std::span<StringParameter> parameters = {}; 
 
  size_t offset = 0; 
  char32_t next_type = 0; 
 
  const StringParameter &GetNextParameterReference();
 
public:
  StringParameters(StringParameters &parent, size_t size) :
    parent(&parent),
    parameters(parent.parameters.subspan(parent.offset, size))
  {}
  StringParameters(StringParameters &parent, size_t size) : {…}
 
  StringParameters(std::span<StringParameter> parameters = {}) : parameters(parameters) {}
 
  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 SetOffset(size_t offset) {…}
 
  void AdvanceOffset(size_t advance)
  {
    this->offset += advance;
    assert(this->offset <= this->parameters.size());
  }
  void AdvanceOffset(size_t advance) {…}
 
  uint64_t GetNextParameter()
  {
    struct visitor {
      uint64_t operator()(const std::monostate &) { throw std::out_of_range("Attempt to read uninitialised parameter as integer"); }
      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 = this->GetNextParameterReference();
    return std::visit(visitor{}, param.data);
  }
  uint64_t GetNextParameter() {…}
 
  template <typename T>
  T GetNextParameter()
  {
    return static_cast<T>(this->GetNextParameter());
  }
  T GetNextParameter() {…}
 
  std::string_view GetNextParameterString()
  {
    struct visitor {
      std::string_view operator()(const std::monostate &) { throw std::out_of_range("Attempt to read uninitialised parameter as string"); }
      std::string_view operator()(const uint64_t &) { throw std::out_of_range("Attempt to read integer parameter as string"); }
      std::string_view operator()(const std::string &arg) { return arg; }
    };
 
    const auto &param = this->GetNextParameterReference();
    return std::visit(visitor{}, param.data);
  }
  std::string_view GetNextParameterString() {…}
 
  StringParameters GetRemainingParameters() { return GetRemainingParameters(this->offset); }
 
  StringParameters GetRemainingParameters(size_t offset)
  {
    return StringParameters(this->parameters.subspan(offset, this->parameters.size() - offset));
  }
  StringParameters GetRemainingParameters(size_t offset) {…}
 
  size_t GetDataLeft() const
  {
    return this->parameters.size() - this->offset;
  }
  size_t GetDataLeft() const {…}
 
  size_t GetNumParameters() const
  {
    return this->parameters.size();
  }
  size_t GetNumParameters() const {…}
 
  char32_t GetTypeAtOffset(size_t offset) const
  {
    assert(offset < this->parameters.size());
    return this->parameters[offset].type;
  }
  char32_t GetTypeAtOffset(size_t offset) const {…}
 
  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;
  }
 
  void SetParam(size_t n, ConvertibleThroughBase auto v)
  {
    SetParam(n, v.base());
  }
 
  void SetParam(size_t n, const std::string &str)
  {
    assert(n < this->parameters.size());
    this->parameters[n].data = 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;
  }
};
class StringParameters {…};
 
void GetStringWithArgs(StringBuilder &builder, StringID string, StringParameters &args, uint case_index = 0, bool game_script = false);
void GetStringWithArgs(StringBuilder &builder, StringID string, std::span<StringParameter> params, 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);
 
char32_t RemapNewGRFStringControlCode(char32_t scc, StringConsumer &consumer);
 
#endif /* STRINGS_INTERNAL_H */