BACKENDS: Make DefaultSaveFileManager case insensitive.

For this we introduce a file cache inside DefaultSaveFileManager similar to
what we use inside FSDirectory. However, we only do small updates for newly
created saves (via openForSaving) or for removed saves (via removeSavefile).
Re-caching is done whenever the savepath changes.

Tizen changes have not been tested.

backends/platform/tizen/system.cpp

@@ -81,36 +81,41 @@ struct TizenSaveFileManager : public DefaultSaveFileManager {
 };
 
 bool TizenSaveFileManager::removeSavefile(const Common::String &filename) {
-	Common::String savePathName = getSavePath();
+	// Assure the savefile name cache is up-to-date.
+	assureCached(getSavePath());
+	if (getError().getCode() != Common::kNoError)
+		return false;
+
+	// Obtain node if exists.
+	SaveFileCache::const_iterator file = _saveFileCache.find(filename);
+	if (file == _saveFileCache.end()) {
+		return false;
+	} else {
+		const Common::FSNode fileNode = file->_value;
+		// Remove from cache, this invalidates the 'file' iterator.
+		_saveFileCache.erase(file);
+		file = _saveFileCache.end();
+
+		String unicodeFileName;
+		StringUtil::Utf8ToString(fileNode.getPath().c_str(), unicodeFileName);
+
+		switch (Tizen::Io::File::Remove(unicodeFileName)) {
+		case E_SUCCESS:
+			return true;
+
+		case E_ILLEGAL_ACCESS:
+			setError(Common::kWritePermissionDenied, "Search or write permission denied: " +
+						file.getName());
+			break;
+
+		default:
+			setError(Common::kPathDoesNotExist, "removeSavefile: '" + file.getName() +
+						"' does not exist or path is invalid");
+			break;
+		}
 
-	checkPath(Common::FSNode(savePathName));
-	if (getError().getCode() != Common::kNoError) {
 		return false;
 	}
-
-	// recreate FSNode since checkPath may have changed/created the directory
-	Common::FSNode savePath(savePathName);
-	Common::FSNode file = savePath.getChild(filename);
-
-	String unicodeFileName;
-	StringUtil::Utf8ToString(file.getPath().c_str(), unicodeFileName);
-
-	switch (Tizen::Io::File::Remove(unicodeFileName)) {
-	case E_SUCCESS:
-		return true;
-
-	case E_ILLEGAL_ACCESS:
-		setError(Common::kWritePermissionDenied, "Search or write permission denied: " +
-					file.getName());
-		break;
-
-	default:
-		setError(Common::kPathDoesNotExist, "removeSavefile: '" + file.getName() +
-					"' does not exist or path is invalid");
-		break;
-	}
-
-	return false;
 }
 
 //

backends/saves/default/default-saves.cpp

@@ -60,22 +60,15 @@ void DefaultSaveFileManager::checkPath(const Common::FSNode &dir) {
 }
 
 Common::StringArray DefaultSaveFileManager::listSavefiles(const Common::String &pattern) {
-	Common::String savePathName = getSavePath();
+	// Assure the savefile name cache is up-to-date.
-	checkPath(Common::FSNode(savePathName));
+	assureCached(getSavePath());
 	if (getError().getCode() != Common::kNoError)
 		return Common::StringArray();
 
-	// recreate FSNode since checkPath may have changed/created the directory
-	Common::FSNode savePath(savePathName);
-
-	Common::FSDirectory dir(savePath);
-	Common::ArchiveMemberList savefiles;
 	Common::StringArray results;
-	Common::String search(pattern);
+	for (SaveFileCache::const_iterator file = _saveFileCache.begin(), end = _saveFileCache.end(); file != end; ++file) {
-
+		if (file->_key.matchString(pattern, true)) {
-	if (dir.listMatchingMembers(savefiles, search) > 0) {
+			results.push_back(file->_key);
-		for (Common::ArchiveMemberList::const_iterator file = savefiles.begin(); file != savefiles.end(); ++file) {
-			results.push_back((*file)->getName());
 		}
 	}
 
@@ -83,68 +76,81 @@ Common::StringArray DefaultSaveFileManager::listSavefiles(const Common::String &
 }
 
 Common::InSaveFile *DefaultSaveFileManager::openForLoading(const Common::String &filename) {
-	// Ensure that the savepath is valid. If not, generate an appropriate error.
+	// Assure the savefile name cache is up-to-date.
-	Common::String savePathName = getSavePath();
+	assureCached(getSavePath());
-	checkPath(Common::FSNode(savePathName));
 	if (getError().getCode() != Common::kNoError)
-		return 0;
+		return nullptr;
 
-	// recreate FSNode since checkPath may have changed/created the directory
+	SaveFileCache::const_iterator file = _saveFileCache.find(filename);
-	Common::FSNode savePath(savePathName);
+	if (file == _saveFileCache.end()) {
-
+		return nullptr;
-	Common::FSNode file = savePath.getChild(filename);
+	} else {
-	if (!file.exists())
+		// Open the file for loading.
-		return 0;
+		Common::SeekableReadStream *sf = file->_value.createReadStream();
-
+		return Common::wrapCompressedReadStream(sf);
-	// Open the file for reading
+	}
-	Common::SeekableReadStream *sf = file.createReadStream();
-
-	return Common::wrapCompressedReadStream(sf);
 }
 
 Common::OutSaveFile *DefaultSaveFileManager::openForSaving(const Common::String &filename, bool compress) {
-	// Ensure that the savepath is valid. If not, generate an appropriate error.
+	// Assure the savefile name cache is up-to-date.
-	Common::String savePathName = getSavePath();
+	const Common::String savePathName = getSavePath();
-	checkPath(Common::FSNode(savePathName));
+	assureCached(savePathName);
 	if (getError().getCode() != Common::kNoError)
-		return 0;
+		return nullptr;
 
-	// recreate FSNode since checkPath may have changed/created the directory
+	// Obtain node.
-	Common::FSNode savePath(savePathName);
+	SaveFileCache::const_iterator file = _saveFileCache.find(filename);
+	Common::FSNode fileNode;
 
-	Common::FSNode file = savePath.getChild(filename);
+	// If the file did not exist before, we add it to the cache.
+	if (file == _saveFileCache.end()) {
+		const Common::FSNode savePath(savePathName);
+		fileNode = savePath.getChild(filename);
+	} else {
+		fileNode = file->_value;
+	}
 
-	// Open the file for saving
+	// Open the file for saving.
-	Common::WriteStream *sf = file.createWriteStream();
+	Common::WriteStream *const sf = fileNode.createWriteStream();
+	Common::OutSaveFile *const result = compress ? Common::wrapCompressedWriteStream(sf) : sf;
 
-	return compress ? Common::wrapCompressedWriteStream(sf) : sf;
+	// Add file to cache now that it exists.
+	_saveFileCache[filename] = Common::FSNode(fileNode.getPath());
+
+	return result;
 }
 
 bool DefaultSaveFileManager::removeSavefile(const Common::String &filename) {
-	Common::String savePathName = getSavePath();
+	// Assure the savefile name cache is up-to-date.
-	checkPath(Common::FSNode(savePathName));
+	assureCached(getSavePath());
 	if (getError().getCode() != Common::kNoError)
 		return false;
 
-	// recreate FSNode since checkPath may have changed/created the directory
+	// Obtain node if exists.
-	Common::FSNode savePath(savePathName);
+	SaveFileCache::const_iterator file = _saveFileCache.find(filename);
-
+	if (file == _saveFileCache.end()) {
-	Common::FSNode file = savePath.getChild(filename);
-
-	// FIXME: remove does not exist on all systems. If your port fails to
-	// compile because of this, please let us know (scummvm-devel or Fingolfin).
-	// There is a nicely portable workaround, too: Make this method overloadable.
-	if (remove(file.getPath().c_str()) != 0) {
-#ifndef _WIN32_WCE
-		if (errno == EACCES)
-			setError(Common::kWritePermissionDenied, "Search or write permission denied: "+file.getName());
-
-		if (errno == ENOENT)
-			setError(Common::kPathDoesNotExist, "removeSavefile: '"+file.getName()+"' does not exist or path is invalid");
-#endif
 		return false;
 	} else {
-		return true;
+		const Common::FSNode fileNode = file->_value;
+		// Remove from cache, this invalidates the 'file' iterator.
+		_saveFileCache.erase(file);
+		file = _saveFileCache.end();
+
+		// FIXME: remove does not exist on all systems. If your port fails to
+		// compile because of this, please let us know (scummvm-devel or Fingolfin).
+		// There is a nicely portable workaround, too: Make this method overloadable.
+		if (remove(fileNode.getPath().c_str()) != 0) {
+#ifndef _WIN32_WCE
+			if (errno == EACCES)
+				setError(Common::kWritePermissionDenied, "Search or write permission denied: "+fileNode.getName());
+
+			if (errno == ENOENT)
+				setError(Common::kPathDoesNotExist, "removeSavefile: '"+fileNode.getName()+"' does not exist or path is invalid");
+#endif
+			return false;
+		} else {
+			return true;
+		}
 	}
 }
 
@@ -171,4 +177,43 @@ Common::String DefaultSaveFileManager::getSavePath() const {
 	return dir;
 }
 
+void DefaultSaveFileManager::assureCached(const Common::String &savePathName) {
+	// Check that path exists and is usable.
+	checkPath(Common::FSNode(savePathName));
+
+	if (_cachedDirectory == savePathName) {
+		return;
+	}
+
+	_saveFileCache.clear();
+	_cachedDirectory.clear();
+
+	if (getError().getCode() != Common::kNoError) {
+		warning("DefaultSaveFileManager::assureCached: Can not cache path '%s': '%s'", savePathName.c_str(), getErrorDesc().c_str());
+		return;
+	}
+
+	// FSNode can cache its members, thus create it after checkPath to reflect
+	// actual file system state.
+	const Common::FSNode savePath(savePathName);
+
+	Common::FSList children;
+	if (!savePath.getChildren(children, Common::FSNode::kListFilesOnly)) {
+		return;
+	}
+
+	// Build the savefile name cache.
+	for (Common::FSList::const_iterator file = children.begin(), end = children.end(); file != end; ++file) {
+		if (_saveFileCache.contains(file->getName())) {
+			warning("DefaultSaveFileManager::assureCached: Name clash when building cache, ignoring file '%s'", file->getName().c_str());
+		} else {
+			_saveFileCache[file->getName()] = *file;
+		}
+	}
+
+	// Only now store that we cached 'savePathName' to indicate we successfully
+	// cached the directory.
+	_cachedDirectory = savePathName;
+}
+
 #endif // !defined(DISABLE_DEFAULT_SAVEFILEMANAGER)

backends/saves/default/default-saves.h

@@ -27,6 +27,7 @@
 #include "common/savefile.h"
 #include "common/str.h"
 #include "common/fs.h"
+#include "common/hashmap.h"
 
 /**
  * Provides a default savefile manager implementation for common platforms.
@@ -54,6 +55,30 @@ protected:
 	 * Sets the internal error and error message accordingly.
 	 */
 	virtual void checkPath(const Common::FSNode &dir);
+
+	/**
+	 * Assure that the given save path is cached.
+	 *
+	 * @param savePathName  String representation of save path to cache.
+	 */
+	void assureCached(const Common::String &savePathName);
+
+	typedef Common::HashMap<Common::String, Common::FSNode, Common::IgnoreCase_Hash, Common::IgnoreCase_EqualTo> SaveFileCache;
+
+	/**
+	 * Cache of all the save files in the currently cached directory.
+	 *
+	 * Modify with caution because we only re-cache when the save path changed!
+	 * This needs to be updated inside at least openForSaving and
+	 * removeSavefile.
+	 */
+	SaveFileCache _saveFileCache;
+
+private:
+	/**
+	 * The currently cached directory.
+	 */
+	Common::String _cachedDirectory;
 };
 
 #endif