base_media_base.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 <https://www.gnu.org/licenses/old-licenses/gpl-2.0>.
 */

 
#ifndef BASE_MEDIA_BASE_H
#define BASE_MEDIA_BASE_H
 
#include "fileio_func.h"
#include "textfile_type.h"
#include "textfile_gui.h"
#include "3rdparty/md5/md5.h"
#include <unordered_map>
 
struct IniFile;
struct IniGroup;
struct IniItem;
struct ContentInfo;

struct MD5File {
  enum ChecksumResult : uint8_t {
    CR_UNKNOWN,  
    CR_MATCH,    
    CR_MISMATCH, 
    CR_NO_FILE,  
  };
 
  std::string filename;        
  MD5Hash hash;                
  std::string missing_warning; 
  ChecksumResult check_result; 
 
  ChecksumResult CheckMD5(Subdirectory subdir, size_t max_size) const;
};

template <class T> struct BaseSetTraits;

template <class T>
struct BaseSet {
  virtual ~BaseSet() = default;
 
  typedef std::unordered_map<std::string, std::string, StringHash, std::equal_to<>> TranslatedStrings;

  static constexpr size_t NUM_FILES = BaseSetTraits<T>::num_files;

  static constexpr bool SEARCH_IN_TARS = BaseSetTraits<T>::search_in_tars;

  static constexpr std::string_view SET_TYPE = BaseSetTraits<T>::set_type;
 
  std::string name;              
  std::string url;               
  TranslatedStrings description; 
  uint32_t shortname = 0; 
  std::vector<uint32_t> version; 
  bool fallback = false; 
 
  std::array<MD5File, BaseSet<T>::NUM_FILES> files{}; 
  uint found_files = 0; 
  uint valid_files = 0; 

  int GetNumMissing() const
  {
    return BaseSet<T>::NUM_FILES - this->found_files;
  }

  int GetNumInvalid() const
  {
    return BaseSet<T>::NUM_FILES - this->valid_files;
  }
 
  void LogError(std::string_view full_filename, std::string_view detail, int level = 0) const;
  const IniItem *GetMandatoryItem(std::string_view full_filename, const IniGroup &group, std::string_view name) const;
 
  bool FillSetDetails(const IniFile &ini, const std::string &path, const std::string &full_filename, bool allow_empty_filename = true);
  void CopyCompatibleConfig([[maybe_unused]] const T &src) {}

  const std::string &GetDescription(std::string_view isocode) const
  {
    if (!isocode.empty()) {
      /* First the full ISO code */
      auto desc = this->description.find(isocode);
      if (desc != this->description.end()) return desc->second;
 
      /* Then the first two characters */
      desc = this->description.find(isocode.substr(0, 2));
      if (desc != this->description.end()) return desc->second;
    }
    /* Then fall back */
    return this->description.at(std::string{});
  }

  static MD5File::ChecksumResult CheckMD5(const MD5File *file, Subdirectory subdir)
  {
    return file->CheckMD5(subdir, SIZE_MAX);
  }

  std::optional<std::string> GetTextfile(TextfileType type) const
  {
    for (const auto &file : this->files) {
      auto textfile = ::GetTextfile(type, BASESET_DIR, file.filename);
      if (textfile.has_value()) {
        return textfile;
      }
    }
    return std::nullopt;
  }

  static std::span<const std::string_view> GetFilenames();
};

template <class Tbase_set>
class BaseMedia : FileScanner {
protected:
  static inline std::vector<std::unique_ptr<Tbase_set>> available_sets; 
  static inline std::vector<std::unique_ptr<Tbase_set>> duplicate_sets; 
  static inline const Tbase_set *used_set; 
 
  bool AddFile(const std::string &filename, size_t basepath_length, const std::string &tar_filename) override;

  static std::string_view GetExtension();

   static std::span<const std::unique_ptr<Tbase_set>> GetDuplicateSets() { return BaseMedia<Tbase_set>::duplicate_sets; }
public:
  static bool DetermineBestSet();

  static uint FindSets()
  {
    BaseMedia<Tbase_set> fs;
    /* Searching in tars is only done in the old "data" directories basesets. */
    uint num = fs.Scan(GetExtension(), Tbase_set::SEARCH_IN_TARS ? OLD_DATA_DIR : OLD_GM_DIR, Tbase_set::SEARCH_IN_TARS);
    return num + fs.Scan(GetExtension(), BASESET_DIR, Tbase_set::SEARCH_IN_TARS);
  }

  static std::span<const std::unique_ptr<Tbase_set>> GetAvailableSets() { return BaseMedia<Tbase_set>::available_sets; }
 
  static bool SetSet(const Tbase_set *set);
  static bool SetSetByName(const std::string &name);
  static bool SetSetByShortname(uint32_t shortname);
  static void GetSetsList(std::back_insert_iterator<std::string> &output_iterator);
  static int GetNumSets();
  static int GetIndexOfUsedSet();
  static const Tbase_set *GetSet(int index);
  static const Tbase_set *GetUsedSet();

  static bool HasSet(const ContentInfo &ci, bool md5sum);
};

template <class Tbase_set>
std::optional<std::string_view> TryGetBaseSetFile(const ContentInfo &ci, bool md5sum, std::span<const std::unique_ptr<Tbase_set>> sets);
 
#endif /* BASE_MEDIA_BASE_H */