Don’t check file types that are not in the RomDB.

Author: dillof

src/Fixdat.cc

@@ -68,7 +68,7 @@ void Fixdat::write(const Game *game, const Result *result) {
 
     auto empty = true;
 
-    for (size_t ft = 0; ft < TYPE_MAX; ft++) {
+    for (auto ft: db->filetypes()) {
         for (size_t i = 0; i < game->files[ft].size(); i++) {
             auto &match = result->game_files[ft][i];
             auto &rom = game->files[ft][i];

src/RomDB.cc

@@ -133,7 +133,7 @@ std::unordered_map<int, std::string> RomDB::queries = {
     {  QUERY_FILE, "select name, merge, status, location, size, crc, md5, sha1, sha256, missing from file where game_id = :game_id and file_type = :file_type order by file_idx" },
     {  QUERY_GAME_ID, "select game_id from game where name = :name" },
     {  QUERY_GAME, "select game_id, description, dat_idx, parent from game where name = :name" },
-    {  QUERY_HAS_DISKS, "select file_idx from file where file_type = 1 limit 1" },
+    {  QUERY_HAS_FILE_TYPE, "select file_idx from file where file_type = :file_type limit 1" },
     {  QUERY_HASH_TYPE_CRC, "select name from file where file_type = :file_type and crc not null limit 1" },
     {  QUERY_HASH_TYPE_MD5, "select name from file where file_type = :file_type and md5 not null limit 1" },
     {  QUERY_HASH_TYPE_SHA1, "select name from file where file_type = :file_type and sha1 not null limit 1" },
@@ -216,9 +216,9 @@ Stats RomDB::get_stats() {
 }
 
 
-bool RomDB::has_disks() {
-    auto stmt = get_statement(QUERY_HAS_DISKS);
-
+bool RomDB::get_has_type(int type) {
+    auto stmt = get_statement(QUERY_HAS_FILE_TYPE);
+    stmt->set_int("file_type", type);
     return stmt->step();
 }
 
@@ -227,9 +227,35 @@ int RomDB::hashtypes(filetype_t type) {
     if (hashtypes_[type] == -1) {
         read_hashtypes(type);
     }
-    
+
     return hashtypes_[type];
 }
+RomDB::FileTypes RomDB::filetypes() {
+    for (int i = 0; i < TYPE_MAX; i++) {
+        (void)has_type(static_cast<filetype_t>(i));
+    }
+    return {*this};
+}
+
+RomDB::FileTypeIterator::FileTypeIterator(const bool* types, int file_type) : types{types}, file_type{file_type} {
+    skip_missing();
+}
+
+
+RomDB::FileTypeIterator& RomDB::FileTypeIterator::operator++() {
+    if (file_type < TYPE_MAX) {
+        file_type++;
+    }
+    skip_missing();
+    return *this;
+}
+
+void RomDB::FileTypeIterator::skip_missing() {
+    while (file_type < TYPE_MAX && !types[file_type]) {
+        file_type++;
+    }
+}
+
 
 
 RomDB::RomDB(const std::string &name, int mode) : DB(format, name, mode) {
@@ -243,6 +269,10 @@ RomDB::RomDB(const std::string &name, int mode) : DB(format, name, mode) {
         auto detector_id = Detector::get_id(DetectorDescriptor(stmt->get_string("name"), stmt->get_string("version")));
         detectors[detector_id] = read_detector();
     }
+
+    for (size_t i = 0; i < TYPE_MAX; i++) {
+        has_types[i] = get_has_type(i);
+    }
 }
 
 

src/RomDB.h

@@ -59,7 +59,7 @@ class RomDB : public DB {
         QUERY_FILE,
         QUERY_GAME_ID,
         QUERY_GAME,
-        QUERY_HAS_DISKS,
+        QUERY_HAS_FILE_TYPE,
         QUERY_HASH_TYPE_CRC,
         QUERY_HASH_TYPE_MD5,
         QUERY_HASH_TYPE_SHA1,
@@ -80,6 +80,36 @@ class RomDB : public DB {
     enum ParameterizedStatement {
         QUERY_FILE_FBH
     };
+
+    class FileTypeIterator {
+        public:
+            using iterator_category = std::forward_iterator_tag;
+            using value_type = filetype_t;
+
+            FileTypeIterator(const bool* types, int file_type);
+
+            FileTypeIterator& operator++();
+            FileTypeIterator operator++(int) {auto next=*this; ++*this; return next;}
+            filetype_t operator*() const {return static_cast<filetype_t>(file_type);}
+            bool operator==(const FileTypeIterator& other) const {return file_type == other.file_type;}
+            bool operator!=(const FileTypeIterator& other) const {return file_type != other.file_type;}
+
+        private:
+            void skip_missing();
+            const bool* types;
+            int file_type;
+    };
+
+    class FileTypes {
+        public:
+            FileTypes(const RomDB& db): types{db.has_types} {}
+
+            FileTypeIterator begin() {return {types, 0};}
+            FileTypeIterator end() {return {types, TYPE_MAX};}
+
+        private:
+           const bool *types;
+    };
 
     RomDB(const std::string &name, int mode);
     ~RomDB() override = default;
@@ -96,7 +126,8 @@ class RomDB : public DB {
     std::vector<std::string> get_clones(const std::string &game_name);
     void delete_game(const Game *game) { delete_game(game->name); }
     void delete_game(const std::string &name);
-    bool has_disks();
+    bool has_type(filetype_t type) const {return has_types[type];}
+    bool has_disks() const {return has_type(TYPE_DISK);}
 
     bool has_detector() const { return !detectors.empty(); }
     DetectorPtr get_detector(size_t id);
@@ -107,6 +138,7 @@ class RomDB : public DB {
     std::vector<RomLocation> read_file_by_hash(filetype_t ft, const Hashes &hashes);
     GamePtr read_game(const std::string &name);
     int hashtypes(filetype_t);
+    FileTypes filetypes();
     std::vector<std::string> read_list(enum dbh_list type);
     void update_file_location(Game *game);
     void update_game_parent(const Game *game);
@@ -115,13 +147,15 @@ class RomDB : public DB {
     void write_game(Game *game);
     void write_hashtypes(int, int);
     int export_db(const std::unordered_set<std::string> &exclude, const DatEntry *dat, OutputContext *out);
-    
+
+    bool has_types[TYPE_MAX];
+
 protected:
     std::string get_query(int name, bool parameterized) const override;
 
 private:
     int hashtypes_[TYPE_MAX];
-    
+
     static const std::string init2_sql;
     static const Statement query_hash_type[];
     static std::unordered_map<int, std::string> queries;
@@ -130,6 +164,7 @@ class RomDB : public DB {
     DBStatement *get_statement(Statement name) { return get_statement_internal(name); }
     DBStatement *get_statement(ParameterizedStatement name, const Hashes &hashes, bool have_size) { return get_statement_internal(name, hashes, have_size); }
 
+    bool get_has_type(int type);
     DetectorPtr read_detector();
     void read_files(Game *game, filetype_t ft);
     void read_hashtypes(filetype_t type);

src/Tree.cc

@@ -50,11 +50,11 @@ Tree check_tree;
 
 bool Tree::add(const std::string &game_name) {
     GamePtr game = db->read_game(game_name);
-    
+
     if (!game) {
 	return false;
     }
-    
+
     auto tree = this;
 
     if (!game->cloneof[1].empty()) {
@@ -117,21 +117,19 @@ void Tree::traverse() {
 
 void Tree::traverse_internal(GameArchives *ancestor_archives) {
     GameArchives archives[] = { GameArchives(), ancestor_archives[0], ancestor_archives[1] };
-    
+
     Progress::push_message("checking " + name);
 
     auto flags = check ? ARCHIVE_FL_CREATE : 0;
-    
-    for (size_t ft = 0; ft < TYPE_MAX; ft++) {
-        auto filetype = static_cast<filetype_t>(ft);
-        
+
+    for (auto filetype: db->filetypes()) {
         auto full_name = findfile(filetype, name);
 
         if (full_name.empty() && check) {
             full_name = make_file_name(filetype, name);
         }
         if (!full_name.empty()) {
-            archives[0].archive[ft] = Archive::open(full_name, filetype, FILE_ROMSET, flags);
+            archives[0].archive[filetype] = Archive::open(full_name, filetype, FILE_ROMSET, flags);
         }
     }
 
@@ -149,7 +147,7 @@ void Tree::traverse_internal(GameArchives *ancestor_archives) {
 
 Tree *Tree::add_node(const std::string &game_name, bool do_check) {
     auto it = children.find(game_name);
-    
+
     if (it == children.end()) {
         auto child = std::make_shared<Tree>(game_name, do_check);
         children[game_name] = child;
@@ -166,7 +164,7 @@ Tree *Tree::add_node(const std::string &game_name, bool do_check) {
 
 void Tree::process(GameArchives *archives) {
     auto game = db->read_game(name);
-    
+
     if (!game) {
 	output.error("db error: %s not found", name.c_str());
         return;
@@ -178,9 +176,9 @@ void Tree::process(GameArchives *archives) {
 	Result res(game.get(), archives[0]);
 
 	check_old(game.get(), &res);
-	for (size_t ft = 0; ft < TYPE_MAX; ft++) {
-	    check_game_files(game.get(), static_cast<filetype_t>(ft), archives, &res);
-	    check_archive_files(static_cast<filetype_t>(ft), archives[0], game->name, &res);
+        for (auto ft: db->filetypes()) {
+	    check_game_files(game.get(), ft, archives, &res);
+	    check_archive_files(ft, archives[0], game->name, &res);
 	}
 	update_game_status(game.get(), &res);
 

src/check_game_files.cc

@@ -256,9 +256,7 @@ void update_game_status(const Game* game, Result* result) {
     auto has_own = false;
     auto have_mia = false;
 
-    for (size_t ft = 0; ft < TYPE_MAX; ft++) {
-        auto filetype = static_cast<filetype_t>(ft);
-
+    for (auto filetype: db->filetypes()) {
         for (size_t i = 0; i < game->files[filetype].size(); i++) {
             auto match = &result->game_files[filetype][i];
             auto& rom = game->files[filetype][i];

src/check_old.cc

@@ -44,9 +44,7 @@ check_old(Game *game, Result *result) {
 
     auto all_old = true;
 
-    for (size_t ft = 0; ft < TYPE_MAX; ft++) {
-        auto filetype = static_cast<filetype_t>(ft);
-        
+    for (auto filetype: db->filetypes()) {
         for (size_t i = 0; i < game->files[filetype].size(); i++) {
             if (find_in_old(filetype, &game->files[filetype][i], nullptr, &result->game_files[filetype][i]) != FIND_EXISTS) {
                 all_old = false;

src/diagnostics.cc

@@ -50,9 +50,7 @@ static void diagnostics_game(filetype_t ft, const Game *game, const Result &resu
 void diagnostics(const Game *game, const GameArchives &archives, const Result &result) {
     ckmame_cache->stats.add_game(result.game);
 
-    for (size_t ft = 0; ft < TYPE_MAX; ft++) {
-        auto filetype = static_cast<filetype_t>(ft);
-
+    for (auto filetype: db->filetypes()) {
         for (size_t i = 0; i < game->files[filetype].size(); i++) {
             ckmame_cache->stats.add_rom(filetype, &game->files[filetype][i], result.game_files[filetype][i].quality);
         }

src/fix.cc

@@ -54,8 +54,7 @@ static int clear_incomplete(Game *game, filetype_t filetype, Archive *archive, R
 int fix_game(Game *game, const GameArchives archives, Result *result) {
     int ret = 0;
 
-    for (size_t ft = 0; ft < TYPE_MAX; ft++) {
-        auto filetype = static_cast<filetype_t>(ft);
+    for (auto filetype: db->filetypes()) {
         Archive *archive = archives[filetype];
         GarbagePtr garbage;
         DeleteList::Mark extra_mark, needed_mark, superfluous_mark;
@@ -164,8 +163,7 @@ int fix_save_needed_from_unknown(Game *game, const GameArchives archives, Result
     auto needs_recheck = false;
 
     if (configuration.fix_romset) {
-	for (size_t ft = 0; ft < TYPE_MAX; ft++) {
-	    auto filetype = static_cast<filetype_t>(ft);
+        for (auto filetype: db->filetypes()) {
 	    auto garbage_name = make_garbage_name(archives[filetype]->name, 0);
 
 	    warn_set_info(WARN_TYPE_ARCHIVE, garbage_name);