settings_internal.h

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 <http://www.gnu.org/licenses/>.
 */
 
#ifndef SETTINGS_INTERNAL_H
#define SETTINGS_INTERNAL_H
 
#include <variant>
#include "saveload/saveload.h"
 
enum class SettingFlag : uint8_t {
  GuiZeroIsSpecial, 
  GuiDropdown, 
  GuiCurrency, 
  NetworkOnly, 
  NoNetwork, 
  NewgameOnly, 
  SceneditToo, 
  SceneditOnly, 
  PerCompany, 
  NotInSave, 
  NotInConfig, 
  NoNetworkSync, 
  Sandbox, 
};
enum class SettingFlag : uint8_t {…};
using SettingFlags = EnumBitSet<SettingFlag, uint16_t>;
 
enum SettingCategory : uint8_t {
  SC_NONE = 0,
 
  /* Filters for the list */
  SC_BASIC_LIST      = 1 << 0,    
  SC_ADVANCED_LIST   = 1 << 1,    
  SC_EXPERT_LIST     = 1 << 2,    
 
  /* Setting classification */
  SC_BASIC           = SC_BASIC_LIST | SC_ADVANCED_LIST | SC_EXPERT_LIST,  
  SC_ADVANCED        = SC_ADVANCED_LIST | SC_EXPERT_LIST,                  
  SC_EXPERT          = SC_EXPERT_LIST,                                     
 
  SC_END,
};
enum SettingCategory : uint8_t {…};
 
enum SettingType : uint8_t {
  ST_GAME,      
  ST_COMPANY,   
  ST_CLIENT,    
 
  ST_ALL,       
};
enum SettingType : uint8_t {…};
 
struct IniItem;
 
struct SettingDesc {
  SettingDesc(const SaveLoad &save, SettingFlags flags, bool startup) :
    flags(flags), startup(startup), save(save) {}
  virtual ~SettingDesc() = default;
 
  SettingFlags flags;  
  bool startup;       
  SaveLoad save;      
 
  bool IsEditable(bool do_command = false) const;
  SettingType GetType() const;
 
  constexpr const std::string &GetName() const
  {
    return this->save.name;
  }
  constexpr const std::string &GetName() const {…}
 
  virtual bool IsIntSetting() const { return false; }
 
  virtual bool IsStringSetting() const { return false; }
 
  const struct IntSettingDesc *AsIntSetting() const;
  const struct StringSettingDesc *AsStringSetting() const;
 
  virtual std::string FormatValue(const void *object) const = 0;
 
  virtual void ParseValue(const IniItem *item, void *object) const = 0;
 
  virtual bool IsSameValue(const IniItem *item, void *object) const = 0;
 
  virtual bool IsDefaultValue(void *object) const = 0;
 
  virtual void ResetToDefault(void *object) const = 0;
};
struct SettingDesc {…};
 
struct IntSettingDesc : SettingDesc {
  using GetTitleCallback = StringID(const IntSettingDesc &sd);
  using GetHelpCallback = StringID(const IntSettingDesc &sd);
  using GetValueParamsCallback = std::pair<StringParameter, StringParameter>(const IntSettingDesc &sd, int32_t value);
  using GetDefaultValueCallback = int32_t(const IntSettingDesc &sd);
  using GetRangeCallback = std::tuple<int32_t, uint32_t>(const IntSettingDesc &sd);
 
  using PreChangeCheck = bool(int32_t &value);
  using PostChangeCallback = void(int32_t value);
 
  template <ConvertibleThroughBaseOrTo<int32_t> Tdef, ConvertibleThroughBaseOrTo<int32_t> Tmin, ConvertibleThroughBaseOrTo<uint32_t> Tmax, ConvertibleThroughBaseOrTo<int32_t> Tinterval>
  IntSettingDesc(const SaveLoad &save, SettingFlags flags, bool startup, Tdef def,
      Tmin min, Tmax max, Tinterval interval, StringID str, StringID str_help, StringID str_val,
      SettingCategory cat, PreChangeCheck pre_check, PostChangeCallback post_callback,
      GetTitleCallback get_title_cb, GetHelpCallback get_help_cb, GetValueParamsCallback get_value_params_cb,
      GetDefaultValueCallback get_def_cb, GetRangeCallback get_range_cb) :
    SettingDesc(save, flags, startup),
      str(str), str_help(str_help), str_val(str_val), cat(cat), pre_check(pre_check),
      post_callback(post_callback),
      get_title_cb(get_title_cb), get_help_cb(get_help_cb), get_value_params_cb(get_value_params_cb),
      get_def_cb(get_def_cb), get_range_cb(get_range_cb) {
    if constexpr (ConvertibleThroughBase<Tdef>) {
      this->def = def.base();
    } else {
      this->def = def;
    }
 
    if constexpr (ConvertibleThroughBase<Tmin>) {
      this->min = min.base();
    } else {
      this->min = min;
    }
 
    if constexpr (ConvertibleThroughBase<Tmax>) {
      this->max = max.base();
    } else {
      this->max = max;
    }
 
    if constexpr (ConvertibleThroughBase<Tinterval>) {
      this->interval = interval.base();
    } else {
      this->interval = interval;
    }
  }
 
  int32_t def;              
  int32_t min;              
  uint32_t max;             
  int32_t interval;         
  StringID str;           
  StringID str_help;      
  StringID str_val;       
  SettingCategory cat;    
  PreChangeCheck *pre_check;         
  PostChangeCallback *post_callback; 
  GetTitleCallback *get_title_cb;
  GetHelpCallback *get_help_cb;
  GetValueParamsCallback *get_value_params_cb;
  GetDefaultValueCallback *get_def_cb; 
  GetRangeCallback *get_range_cb;
 
  StringID GetTitle() const;
  StringID GetHelp() const;
  std::pair<StringParameter, StringParameter> GetValueParams(int32_t value) const;
  int32_t GetDefaultValue() const;
  std::tuple<int32_t, uint32_t> GetRange() const;
 
  virtual bool IsBoolSetting() const { return false; }
  bool IsIntSetting() const override { return true; }
 
  void ChangeValue(const void *object, int32_t newvalue) const;
  void MakeValueValidAndWrite(const void *object, int32_t value) const;
 
  virtual int32_t ParseValue(std::string_view str) const;
  std::string FormatValue(const void *object) const override;
  void ParseValue(const IniItem *item, void *object) const override;
  bool IsSameValue(const IniItem *item, void *object) const override;
  bool IsDefaultValue(void *object) const override;
  void ResetToDefault(void *object) const override;
  int32_t Read(const void *object) const;
 
private:
  void MakeValueValid(int32_t &value) const;
  void Write(const void *object, int32_t value) const;
};
struct IntSettingDesc : SettingDesc {…};
 
struct BoolSettingDesc : IntSettingDesc {
  BoolSettingDesc(const SaveLoad &save, SettingFlags flags, bool startup, bool def,
      StringID str, StringID str_help, StringID str_val, SettingCategory cat,
      PreChangeCheck pre_check, PostChangeCallback post_callback,
      GetTitleCallback get_title_cb, GetHelpCallback get_help_cb, GetValueParamsCallback get_value_params_cb,
      GetDefaultValueCallback get_def_cb) :
    IntSettingDesc(save, flags, startup, def ? 1 : 0, 0, 1, 0, str, str_help, str_val, cat,
      pre_check, post_callback, get_title_cb, get_help_cb, get_value_params_cb, get_def_cb, nullptr) {}
 
  static std::optional<bool> ParseSingleValue(std::string_view str);
 
  bool IsBoolSetting() const override { return true; }
  int32_t ParseValue(std::string_view str) const override;
  std::string FormatValue(const void *object) const override;
};
struct BoolSettingDesc : IntSettingDesc {…};
 
struct OneOfManySettingDesc : IntSettingDesc {
  typedef std::optional<uint32_t> OnConvert(std::string_view value); 
 
  template <ConvertibleThroughBaseOrTo<int32_t> Tdef, ConvertibleThroughBaseOrTo<uint32_t> Tmax>
  OneOfManySettingDesc(const SaveLoad &save, SettingFlags flags, bool startup, Tdef def,
      Tmax max, StringID str, StringID str_help, StringID str_val, SettingCategory cat,
      PreChangeCheck pre_check, PostChangeCallback post_callback,
      GetTitleCallback get_title_cb, GetHelpCallback get_help_cb, GetValueParamsCallback get_value_params_cb,
      GetDefaultValueCallback get_def_cb, std::initializer_list<std::string_view> many, OnConvert *many_cnvt) :
    IntSettingDesc(save, flags, startup, def, 0, max, 0, str, str_help, str_val, cat,
      pre_check, post_callback, get_title_cb, get_help_cb, get_value_params_cb, get_def_cb, nullptr), many_cnvt(many_cnvt)
  {
    for (auto one : many) this->many.push_back(one);
  }
 
  std::vector<std::string_view> many; 
  OnConvert *many_cnvt;          
 
  static std::optional<uint32_t> ParseSingleValue(std::string_view str, std::span<const std::string_view> many);
  std::string FormatSingleValue(uint id) const;
 
  int32_t ParseValue(std::string_view str) const override;
  std::string FormatValue(const void *object) const override;
};
struct OneOfManySettingDesc : IntSettingDesc {…};
 
struct ManyOfManySettingDesc : OneOfManySettingDesc {
  template <ConvertibleThroughBaseOrTo<int32_t> Tdef>
  ManyOfManySettingDesc(const SaveLoad &save, SettingFlags flags, bool startup,
    Tdef def, StringID str, StringID str_help, StringID str_val, SettingCategory cat,
    PreChangeCheck pre_check, PostChangeCallback post_callback,
    GetTitleCallback get_title_cb, GetHelpCallback get_help_cb, GetValueParamsCallback get_value_params_cb,
    GetDefaultValueCallback get_def_cb, std::initializer_list<std::string_view> many, OnConvert *many_cnvt) :
    OneOfManySettingDesc(save, flags, startup, def, (1 << many.size()) - 1, str, str_help,
      str_val, cat, pre_check, post_callback, get_title_cb, get_help_cb, get_value_params_cb, get_def_cb, many, many_cnvt) {}
 
  int32_t ParseValue(std::string_view str) const override;
  std::string FormatValue(const void *object) const override;
};
struct ManyOfManySettingDesc : OneOfManySettingDesc {…};
 
struct StringSettingDesc : SettingDesc {
  typedef bool PreChangeCheck(std::string &value);
  typedef void PostChangeCallback(const std::string &value);
 
  StringSettingDesc(const SaveLoad &save, SettingFlags flags, bool startup, std::string_view def,
      uint32_t max_length, PreChangeCheck pre_check, PostChangeCallback post_callback) :
    SettingDesc(save, flags, startup), def(def), max_length(max_length),
      pre_check(pre_check), post_callback(post_callback) {}
 
  std::string_view def; 
  uint32_t max_length;                 
  PreChangeCheck *pre_check;         
  PostChangeCallback *post_callback; 
 
  bool IsStringSetting() const override { return true; }
  void ChangeValue(const void *object, std::string &&newval) const;
 
  std::string FormatValue(const void *object) const override;
  void ParseValue(const IniItem *item, void *object) const override;
  bool IsSameValue(const IniItem *item, void *object) const override;
  bool IsDefaultValue(void *object) const override;
  void ResetToDefault(void *object) const override;
  const std::string &Read(const void *object) const;
 
private:
  void MakeValueValid(std::string &str) const;
  void Write(const void *object, std::string_view str) const;
};
struct StringSettingDesc : SettingDesc {…};
 
struct ListSettingDesc : SettingDesc {
  ListSettingDesc(const SaveLoad &save, SettingFlags flags, bool startup, std::string_view def) :
    SettingDesc(save, flags, startup), def(def) {}
 
  std::string_view def; 
 
  std::string FormatValue(const void *object) const override;
  void ParseValue(const IniItem *item, void *object) const override;
  bool IsSameValue(const IniItem *item, void *object) const override;
  bool IsDefaultValue(void *object) const override;
  void ResetToDefault(void *object) const override;
};
struct ListSettingDesc : SettingDesc {…};
 
struct NullSettingDesc : SettingDesc {
  NullSettingDesc(const SaveLoad &save) :
    SettingDesc(save, SettingFlag::NotInConfig, false) {}
 
  std::string FormatValue(const void *) const override { NOT_REACHED(); }
  void ParseValue(const IniItem *, void *) const override { NOT_REACHED(); }
  bool IsSameValue(const IniItem *, void *) const override { NOT_REACHED(); }
  bool IsDefaultValue(void *) const override { NOT_REACHED(); }
  void ResetToDefault(void *) const override { NOT_REACHED(); }
};
struct NullSettingDesc : SettingDesc {…};
 
typedef std::variant<IntSettingDesc, BoolSettingDesc, OneOfManySettingDesc, ManyOfManySettingDesc, StringSettingDesc, ListSettingDesc, NullSettingDesc> SettingVariant;
 
static constexpr const SettingDesc *GetSettingDesc(const SettingVariant &desc)
{
  return std::visit([](auto&& arg) -> const SettingDesc * { return &arg; }, desc);
}
static constexpr const SettingDesc *GetSettingDesc(const SettingVariant &desc) {…}
 
typedef std::span<const SettingVariant> SettingTable;
 
const SettingDesc *GetSettingFromName(std::string_view name);
void GetSaveLoadFromSettingTable(SettingTable settings, std::vector<SaveLoad> &saveloads);
SettingTable GetSaveLoadSettingTable();
bool SetSettingValue(const IntSettingDesc *sd, int32_t value, bool force_newgame = false);
bool SetSettingValue(const StringSettingDesc *sd, std::string_view value, bool force_newgame = false);
 
std::vector<const SettingDesc *> GetFilteredSettingCollection(std::function<bool(const SettingDesc &desc)> func);
 
#endif /* SETTINGS_INTERNAL_H */