Namespaces
	anonymous_namespace{fs.cpp}

	anonymous_namespace{fsdir.cpp}

	FsDir

	FsZip

	ZipReader

Data Structures
struct	DirEntry

struct	File

struct	FsEntry

struct	FsFuncs

struct	List

struct	ZipEntry

struct	ZipLocalHeader

Functions
void	init (const std::string &name)

void	updateDirSeparator ()

const char *	getDirSeparator ()

const char *	getBaseDir ()

const char *	getUserDir ()

std::vector< FsEntry * > &	getEntries ()

FsEntry *	searchByRootInternal (const std::string &root, const std::string &subDir)

FsEntry *	searchByTypeInternal (const std::string &root, const FsEntryTypeT type)

bool	exists (std::string name)

List *	enumerateFiles (std::string dirName)

void	getFiles (std::string dirName, StringVect &list)

void	getFilesWithDir (std::string dirName, StringVect &list)

void	getDirs (std::string dirName, StringVect &list)

bool	isDirectory (std::string name)

bool	isSymbolicLink (const std::string &name)

void	freeList (List *const handle)

File *	openRead (std::string filename)

File *	openWrite (std::string filename)

File *	openAppend (std::string filename)

bool	setWriteDir (const std::string &newDir)

void	addEntry (FsEntry *const entry, const Append append)

bool	mountDirInternal (const std::string &newDir, std::string subDir, const Append append)

bool	mountDir (std::string newDir, const Append append)

bool	mountDir2 (std::string newDir, std::string subDir, const Append append)

bool	mountDirSilent (std::string newDir, const Append append)

bool	mountDirSilent2 (std::string newDir, std::string subDir, const Append append)

bool	unmountDirInternal (std::string oldDir, std::string subDir)

bool	unmountDir (std::string oldDir)

bool	unmountDir2 (std::string oldDir, std::string subDir)

bool	unmountDirSilent (std::string oldDir)

bool	unmountDirSilent2 (std::string oldDir, std::string subDir)

bool	mountZip (std::string newDir, const Append append)

bool	mountZip2 (std::string newDir, std::string subDir, const Append append)

bool	unmountZip (std::string oldDir)

bool	unmountZip2 (std::string oldDir, std::string subDir)

std::string	getRealDir (std::string fileName)

bool	mkdir (const std::string &dirname)

bool	remove (const std::string &filename)

bool	deinit ()

void	permitLinks (const bool val)

int	close (File *const file)

int64_t	read (File const file, void const buffer, const uint32_t objSize, const uint32_t objCount)

int64_t	write (File const file, const void const buffer, const uint32_t objSize, const uint32_t objCount)

int64_t	fileLength (File *const file)

int64_t	tell (File *const file)

int	seek (File *const file, const uint64_t pos)

int	eof (File *const file)

const char *	loadFile (std::string filename, int &fileSize)

SDL_RWops *	create_rwops (File *const file, const std::string &fname)

SDL_RWops *	rwopsOpenRead (const std::string &fname)

SDL_RWops *	rwopsOpenWrite (const std::string &fname)

SDL_RWops *	rwopsOpenAppend (const std::string &fname)

void	searchAndAddArchives (const std::string &path, const std::string &ext, const Append append)

void	searchAndRemoveArchives (const std::string &path, const std::string &ext)

void	getFilesInDir (const std::string &dir, StringVect &list, const std::string &ext)

std::string	getPath (const std::string &file)

std::string	loadTextFileString (const std::string &fileName)

bool	loadTextFile (const std::string &fileName, StringVect &lines)

Function Documentation

◆ addEntry()

void VirtFs::addEntry	(	FsEntry *const	entry,
		const Append	append
	)

Definition at line 336 of file fs.cpp.

  {
  if (append == Append_true)
  mEntries.push_back(entry);
  else
  mEntries.insert(mEntries.begin(), entry);
  }

References Append_true, and VirtFs::anonymous_namespace{fs.cpp}::mEntries.

Referenced by mountDirInternal(), mountZip(), and mountZip2().

◆ close()

int VirtFs::close ( File *const file )

Definition at line 808 of file fs.cpp.

  {
  if (file == nullptr)
  return 0;
  return file->funcs->close(file);
  }

◆ create_rwops()

SDL_RWops * VirtFs::create_rwops	(	File *const	file,
		const std::string &	fname
	)

Definition at line 66 of file rwops.cpp.

 {
  SDL_RWops *retval = nullptr;
  
  if (file == nullptr)
  {
  reportAlways("VirtFs::rwops_seek: create rwops error: %s",
  fname.c_str())
  }
  else
  {
  retval = SDL_AllocRW();
  if (retval != nullptr)
  {
 #ifdef USE_SDL2
  retval->size = file->funcs->rwops_size;
 #endif // USE_SDL2
  
  retval->seek = file->funcs->rwops_seek;
  retval->read = file->funcs->rwops_read;
  retval->write = file->funcs->rwops_write;
  retval->close = file->funcs->rwops_close;
  retval->hidden.unknown.data1 = file;
  } /* if */
  } /* else */
  
  return retval;
 } /* VirtFs::create_rwops */

References VirtFs::File::funcs, reportAlways, VirtFs::FsFuncs::rwops_close, VirtFs::FsFuncs::rwops_read, VirtFs::FsFuncs::rwops_seek, VirtFs::FsFuncs::rwops_write, and VirtFs::FsFuncs::seek.

Referenced by rwopsOpenAppend(), rwopsOpenRead(), and rwopsOpenWrite().

◆ deinit()

bool VirtFs::deinit ( )

Definition at line 785 of file fs.cpp.

  {
  FsDir::deinit();
  FsZip::deinit();
  FOR_EACH (STD_VECTOR<FsEntry*>::iterator, it, mEntries)
  {
  FsEntry *const entry = *it;
  if (entry->type == FsEntryType::Dir)
  delete static_cast<DirEntry*>(entry);
  else if (entry->type == FsEntryType::Zip)
  delete static_cast<ZipEntry*>(entry);
  else
  delete entry;
  }
  mEntries.clear();
  return true;
  }

References VirtFs::FsDir::deinit(), VirtFs::FsZip::deinit(), FsEntryType::Dir, FOR_EACH, VirtFs::anonymous_namespace{fs.cpp}::mEntries, VirtFs::FsEntry::type, and FsEntryType::Zip.

Referenced by Client::gameClear(), main(), mainGui(), and Client::runValidate().

◆ enumerateFiles()

List * VirtFs::enumerateFiles ( std::string dirName )

Definition at line 147 of file fs.cpp.

  {
  List *const list = new List;
  prepareFsPath(dirName);
  if (checkPath(dirName) == false)
  {
  reportAlways("VirtFs::enumerateFiles invalid path: %s",
  dirName.c_str())
  return list;
  }
  
  std::string rootDir = STD_MOVE(dirName);
  if (findLast(rootDir, std::string(dirSeparator)) == false)
  rootDir += dirSeparator;
  StringVect &names = list->names;
  
  FOR_EACH (STD_VECTOR<FsEntry*>::const_iterator, it, mEntries)
  {
  FsEntry *const entry = *it;
  entry->funcs->enumerate(entry, rootDir, names);
  }
  
  return list;
  }

References checkPath(), dirSeparator, VirtFs::FsFuncs::enumerate, findLast(), FOR_EACH, VirtFs::FsEntry::funcs, VirtFs::anonymous_namespace{fs.cpp}::mEntries, VirtFs::List::names, prepareFsPath(), reportAlways, and STD_MOVE.

Referenced by Theme::fillSoundsList(), Wallpaper::loadWallpapers(), searchAndAddArchives(), and searchAndRemoveArchives().

◆ eof()

int VirtFs::eof ( File *const file )

Definition at line 854 of file fs.cpp.

  {
  return file->funcs->eof(file);
  }

◆ exists()

bool VirtFs::exists ( std::string name )

Definition at line 124 of file fs.cpp.

  {
  prepareFsPath(name);
  if (checkPath(name) == false)
  {
  reportAlways("FsDir::exists invalid path: %s",
  name.c_str())
  return false;
  }
  
  std::string rootDir = name;
  if (findLast(rootDir, std::string(dirSeparator)) == false)
  rootDir += dirSeparator;
  
  FOR_EACH (STD_VECTOR<FsEntry*>::const_iterator, it, mEntries)
  {
  FsEntry *const entry = *it;
  if (entry->funcs->exists(entry, name, rootDir) == true)
  return true;
  }
  return false;
  }

References checkPath(), dirSeparator, VirtFs::FsFuncs::exists, findLast(), FOR_EACH, VirtFs::FsEntry::funcs, VirtFs::anonymous_namespace{fs.cpp}::mEntries, prepareFsPath(), and reportAlways.

Referenced by Game::changeMap(), PoParser::checkLang(), ItemDB::getNamesStr(), Configuration::init(), loadMusic(), Theme::readSkin(), Theme::resolveThemePath(), Minimap::setMap(), Theme::tryThemePath(), and MapReader::updateMusic().

◆ fileLength()

int64_t VirtFs::fileLength ( File *const file )

Definition at line 837 of file fs.cpp.

  {
  return file->funcs->fileLength(file);
  }

◆ freeList()

void VirtFs::freeList ( List *const handle )

Definition at line 269 of file fs.cpp.

  {
  delete handle;
  }

Referenced by Theme::fillSoundsList(), Wallpaper::loadWallpapers(), searchAndAddArchives(), and searchAndRemoveArchives().

◆ getBaseDir()

const char * VirtFs::getBaseDir ( )

Definition at line 79 of file fs.cpp.

  {
  return FsDir::getBaseDir();
  }

References VirtFs::FsDir::getBaseDir().

Referenced by getHomePath(), GettextHelper::initLang(), Dirs::initRootDir(), and mainGui().

◆ getDirs()

void VirtFs::getDirs	(	std::string	dirName,
		StringVect &	list
	)

Definition at line 217 of file fs.cpp.

  {
  prepareFsPath(dirName);
  if (checkPath(dirName) == false)
  {
  reportAlways("VirtFs::enumerateFiles invalid path: %s",
  dirName.c_str())
  return;
  }
  
  std::string rootDir = STD_MOVE(dirName);
  if (findLast(rootDir, std::string(dirSeparator)) == false)
  rootDir += dirSeparator;
  
  FOR_EACH (STD_VECTOR<FsEntry*>::const_iterator, it, mEntries)
  {
  FsEntry *const entry = *it;
  entry->funcs->getDirs(entry, rootDir, list);
  }
  }

References checkPath(), dirSeparator, findLast(), FOR_EACH, VirtFs::FsEntry::funcs, VirtFs::FsFuncs::getDirs, VirtFs::anonymous_namespace{fs.cpp}::mEntries, prepareFsPath(), reportAlways, and STD_MOVE.

Referenced by Theme::fillSkinsList().

◆ getDirSeparator()

const char * VirtFs::getDirSeparator ( )

Definition at line 74 of file fs.cpp.

  {
  return dirSeparator;
  }

References dirSeparator.

◆ getEntries()

std::vector< FsEntry * > & VirtFs::getEntries ( )

Definition at line 89 of file fs.cpp.

  {
  return mEntries;
  }

References VirtFs::anonymous_namespace{fs.cpp}::mEntries.

◆ getFiles()

void VirtFs::getFiles	(	std::string	dirName,
		StringVect &	list
	)

Definition at line 172 of file fs.cpp.

  {
  prepareFsPath(dirName);
  if (checkPath(dirName) == false)
  {
  reportAlways("VirtFs::enumerateFiles invalid path: %s",
  dirName.c_str())
  return;
  }
  
  std::string rootDir = STD_MOVE(dirName);
  if (findLast(rootDir, std::string(dirSeparator)) == false)
  rootDir += dirSeparator;
  
  FOR_EACH (STD_VECTOR<FsEntry*>::const_iterator, it, mEntries)
  {
  FsEntry *const entry = *it;
  entry->funcs->getFiles(entry, rootDir, list);
  }
  }

References checkPath(), dirSeparator, findLast(), FOR_EACH, VirtFs::FsEntry::funcs, VirtFs::FsFuncs::getFiles, VirtFs::anonymous_namespace{fs.cpp}::mEntries, prepareFsPath(), reportAlways, and STD_MOVE.

Referenced by Theme::fillFontsList().

◆ getFilesInDir()

void VirtFs::getFilesInDir	(	const std::string &	dir,
		StringVect &	list,
		const std::string &	ext
	)

Definition at line 81 of file tools.cpp.

  {
  const std::string &path = dir;
  StringVect tempList;
  VirtFs::getFilesWithDir(path, tempList);
  FOR_EACH (StringVectCIter, it, tempList)
  {
  const std::string &str = *it;
  if (findLast(str, ext))
  list.push_back(str);
  }
  std::sort(list.begin(), list.end());
  }

References findLast(), FOR_EACH, and getFilesWithDir().

Referenced by ColorDB::load(), ItemDB::load(), loadDB(), and HelpWindow::loadTags().

◆ getFilesWithDir()

void VirtFs::getFilesWithDir	(	std::string	dirName,
		StringVect &	list
	)

Definition at line 194 of file fs.cpp.

  {
  prepareFsPath(dirName);
  if (checkPath(dirName) == false)
  {
  reportAlways("VirtFs::enumerateFiles invalid path: %s",
  dirName.c_str())
  return;
  }
  
  std::string rootDir = STD_MOVE(dirName);
  if (findLast(rootDir, std::string(dirSeparator)) == false)
  rootDir += dirSeparator;
  
  FOR_EACH (STD_VECTOR<FsEntry*>::const_iterator, it, mEntries)
  {
  FsEntry *const entry = *it;
  entry->funcs->getFilesWithDir(entry, rootDir, list);
  }
  }

References checkPath(), dirSeparator, findLast(), FOR_EACH, VirtFs::FsEntry::funcs, VirtFs::FsFuncs::getFilesWithDir, VirtFs::anonymous_namespace{fs.cpp}::mEntries, prepareFsPath(), reportAlways, and STD_MOVE.

Referenced by getFilesInDir().

◆ getPath()

std::string VirtFs::getPath ( const std::string & file )

Definition at line 97 of file tools.cpp.

  {
  // get the real path to the file
  const std::string tmp = VirtFs::getRealDir(file);
  std::string path;
  
  // if the file is not in the search path, then its empty
  if (!tmp.empty())
  {
  path = pathJoin(tmp, file);
 #if defined __native_client__
  std::string dataZip = "/http/data.zip/";
  if (path.substr(0, dataZip.length()) == dataZip)
  path = path.replace(0, dataZip.length(), "/http/data/");
 #endif // defined __native_client__
  }
  else
  {
  // if not found in search path return the default path
  path = pathJoin(getPackageDir(), file);
  }
  
  return path;
  }

References getPackageDir(), getRealDir(), and pathJoin().

Referenced by Font::openFont(), and WindowManager::setIcon().

◆ getRealDir()

std::string VirtFs::getRealDir ( std::string fileName )

Definition at line 746 of file fs.cpp.

  {
  prepareFsPath(fileName);
  if (checkPath(fileName) == false)
  {
  reportAlways("FsDir::getRealDir invalid path: %s",
  fileName.c_str())
  return std::string();
  }
  
  std::string rootDir = fileName;
  if (findLast(rootDir, std::string(dirSeparator)) == false)
  rootDir += dirSeparator;
  
  FOR_EACH (STD_VECTOR<FsEntry*>::const_iterator, it, mEntries)
  {
  FsEntry *const entry = *it;
  std::string realDir;
  if (entry->funcs->getRealDir(entry,
  fileName,
  rootDir,
  realDir) == true)
  {
  return realDir;
  }
  }
  return std::string();
  }

References checkPath(), dirSeparator, fileName, findLast(), FOR_EACH, VirtFs::FsEntry::funcs, VirtFs::FsFuncs::getRealDir, VirtFs::anonymous_namespace{fs.cpp}::mEntries, prepareFsPath(), and reportAlways.

Referenced by getPath(), searchAndAddArchives(), and searchAndRemoveArchives().

◆ getUserDir()

const char * VirtFs::getUserDir ( )

Definition at line 84 of file fs.cpp.

  {
  return FsDir::getUserDir();
  }

References VirtFs::FsDir::getUserDir().

Referenced by getPicturesDir(), Dirs::initConfigDir(), Dirs::initLocalDataDir(), and Game::saveScreenshot().

◆ init()

void VirtFs::init ( const std::string & name )

Definition at line 58 of file fs.cpp.

  {
  updateDirSeparator();
  FsDir::init(name);
  FsZip::init();
  }

References VirtFs::FsZip::init(), VirtFs::FsDir::init(), and updateDirSeparator().

Referenced by main(), and mainGui().

◆ isDirectory()

bool VirtFs::isDirectory ( std::string name )

Definition at line 239 of file fs.cpp.

  {
  prepareFsPath(name);
  if (checkPath(name) == false)
  {
  reportAlways("VirtFs::isDirectory invalid path: %s",
  name.c_str())
  return false;
  }
  std::string dirName = STD_MOVE(name);
  if (findLast(dirName, std::string(dirSeparator)) == false)
  dirName += dirSeparator;
  
  FOR_EACH (STD_VECTOR<FsEntry*>::const_iterator, it, mEntries)
  {
  FsEntry *const entry = *it;
  bool isDirFlag(false);
  if (entry->funcs->isDirectory(entry, dirName, isDirFlag) == true)
  {
  return isDirFlag;
  }
  }
  return false;
  }

References checkPath(), dirSeparator, findLast(), FOR_EACH, VirtFs::FsEntry::funcs, VirtFs::FsFuncs::isDirectory, VirtFs::anonymous_namespace{fs.cpp}::mEntries, prepareFsPath(), reportAlways, and STD_MOVE.

Referenced by Theme::fillSoundsList(), initDefaultThemePath(), initDefaultWallpaperPaths(), and Dirs::initUpdatesDir().

◆ isSymbolicLink()

bool VirtFs::isSymbolicLink ( const std::string & name )

Definition at line 264 of file fs.cpp.

  {
  return FsDir::isSymbolicLink(name);
  }

References VirtFs::FsDir::isSymbolicLink().

◆ loadFile()

const char * VirtFs::loadFile	(	std::string	filename,
		int &	fileSize
	)

Definition at line 859 of file fs.cpp.

  {
  prepareFsPath(filename);
  if (checkPath(filename) == false)
  {
  reportAlways("VirtFs::loadFile invalid path: %s",
  filename.c_str())
  return nullptr;
  }
  FOR_EACH (STD_VECTOR<FsEntry*>::const_iterator, it, mEntries)
  {
  FsEntry *const entry = *it;
  const char *const buf = entry->funcs->loadFile(entry,
  filename,
  fileSize);
  if (buf != nullptr)
  return buf;
  }
  return nullptr;
  }

References checkPath(), FOR_EACH, VirtFs::FsEntry::funcs, VirtFs::FsFuncs::loadFile, VirtFs::anonymous_namespace{fs.cpp}::mEntries, prepareFsPath(), and reportAlways.

Referenced by XML::Document::Document(), UpdaterWindow::getFileHash(), loadTextFile(), loadTextFileString(), PoParser::openFile(), and TranslationManager::translateFile().

◆ loadTextFile()

bool VirtFs::loadTextFile	(	const std::string &	fileName,
		StringVect &	lines
	)

Definition at line 137 of file tools.cpp.

  {
  int contentsLength;
  const char *fileContents = VirtFs::loadFile(fileName, contentsLength);
  
  if (fileContents == nullptr)
  {
  logger->log("Couldn't load text file: %s", fileName.c_str());
  return false;
  }
  
  std::istringstream iss(std::string(fileContents, contentsLength));
  std::string line;
  
  while (getline(iss, line))
  lines.push_back(line);
  
  delete [] fileContents;
  return true;
  }

References fileName, loadFile(), Logger::log(), and logger.

Referenced by ChatWindow::loadCommandsFile(), PaletteDB::loadPalette(), and HelpWindow::loadTags().

◆ loadTextFileString()

std::string VirtFs::loadTextFileString ( const std::string & fileName )

Definition at line 122 of file tools.cpp.

  {
  int contentsLength;
  const char *fileContents = VirtFs::loadFile(fileName, contentsLength);
  
  if (fileContents == nullptr)
  {
  logger->log("Couldn't load text file: %s", fileName.c_str());
  return std::string();
  }
  const std::string str = std::string(fileContents, contentsLength);
  delete [] fileContents;
  return str;
  }

References fileName, loadFile(), Logger::log(), and logger.

Referenced by ShadersManager::createShader().

◆ mkdir()

bool VirtFs::mkdir ( const std::string & dirname )

Definition at line 775 of file fs.cpp.

  {
  return FsDir::mkdir(dirname);
  }

References VirtFs::FsDir::mkdir().

Referenced by Dirs::initUpdatesDir(), and mkdir_r().

◆ mountDir()

bool VirtFs::mountDir	(	std::string	newDir,
		const Append	append
	)

Definition at line 393 of file fs.cpp.

  {
  prepareFsPath(newDir);
  if (Files::existsLocal(newDir) == false)
  {
  reportNonTests("VirtFs::mount directory not exists: %s",
  newDir.c_str())
  return false;
  }
  return mountDirInternal(newDir, dirSeparator, append);
  }

References dirSeparator, Files::existsLocal(), mountDirInternal(), prepareFsPath(), and reportNonTests.

Referenced by Client::gameExec(), Client::gameInit(), Client::loadData(), UpdaterWindow::loadDirMods(), main(), and Dirs::mountDataDir().

◆ mountDir2()

bool VirtFs::mountDir2	(	std::string	newDir,
		std::string	subDir,
		const Append	append
	)

Definition at line 406 of file fs.cpp.

  {
  prepareFsPath(newDir);
  prepareFsPath(subDir);
  if (Files::existsLocal(newDir) == false)
  {
  reportNonTests("VirtFs::mount directory not exists: %s",
  newDir.c_str())
  return false;
  }
  return mountDirInternal(newDir, subDir, append);
  }

References Files::existsLocal(), mountDirInternal(), prepareFsPath(), and reportNonTests.

◆ mountDirInternal()

bool VirtFs::mountDirInternal	(	const std::string &	newDir,
		std::string	subDir,
		const Append	append
	)

Definition at line 345 of file fs.cpp.

  {
  if (newDir.find(".zip") != std::string::npos)
  {
  reportAlways("Called FsDir::mount with zip archive")
  return false;
  }
  std::string rootDir = newDir;
  if (findLast(rootDir, std::string(dirSeparator)) == false)
  rootDir += dirSeparator;
  if (subDir == dirSeparator)
  {
  subDir.clear();
  }
  else if (!subDir.empty() &&
  findLast(subDir, std::string(dirSeparator)) == false)
  {
  subDir += dirSeparator;
  }
  const FsEntry *const entry = searchByRootInternal(rootDir, subDir);
  if (entry != nullptr)
  {
  reportAlways("VirtFs::mount already exists: %s",
  newDir.c_str())
  return false;
  }
  if (subDir.empty())
  {
  logger->log("Add virtual directory: " + newDir);
  }
  else
  {
  logger->log("Add virtual directory: %s with dir %s",
  newDir.c_str(),
  subDir.c_str());
  }
  
  addEntry(new DirEntry(newDir,
  rootDir,
  subDir,
  rootDir + subDir,
  FsDir::getFuncs()),
  append);
  return true;
  }

References addEntry(), dirSeparator, findLast(), VirtFs::FsDir::getFuncs(), Logger::log(), logger, reportAlways, and searchByRootInternal().

Referenced by mountDir(), mountDir2(), mountDirSilent(), and mountDirSilent2().

◆ mountDirSilent()

bool VirtFs::mountDirSilent	(	std::string	newDir,
		const Append	append
	)

Definition at line 421 of file fs.cpp.

  {
  prepareFsPath(newDir);
  if (Files::existsLocal(newDir) == false)
  {
  logger->log("VirtFs::mount directory not exists: %s",
  newDir.c_str());
  return false;
  }
  return mountDirInternal(newDir, std::string(), append);
  }

References Files::existsLocal(), Logger::log(), logger, mountDirInternal(), and prepareFsPath().

Referenced by Dirs::mountDataDir().

◆ mountDirSilent2()

bool VirtFs::mountDirSilent2	(	std::string	newDir,
		std::string	subDir,
		const Append	append
	)

Definition at line 434 of file fs.cpp.

  {
  prepareFsPath(newDir);
  prepareFsPath(subDir);
  if (Files::existsLocal(newDir) == false)
  {
  logger->log("VirtFs::mount directory not exists: %s",
  newDir.c_str());
  return false;
  }
  return mountDirInternal(newDir, subDir, append);
  }

References Files::existsLocal(), Logger::log(), logger, mountDirInternal(), and prepareFsPath().

◆ mountZip()

bool VirtFs::mountZip	(	std::string	newDir,
		const Append	append
	)

Definition at line 590 of file fs.cpp.

  {
  prepareFsPath(newDir);
  if (Files::existsLocal(newDir) == false)
  {
  reportNonTests("FsZip::mount file not exists: %s",
  newDir.c_str())
  return false;
  }
  if (findLast(newDir, ".zip") == false)
  {
  reportAlways("Called VirtFs::mount without "
  "zip archive")
  return false;
  }
  if (searchByRootInternal(newDir, std::string()) != nullptr)
  {
  reportAlways("FsZip::mount already exists: %s",
  newDir.c_str())
  return false;
  }
  ZipEntry *const entry = new ZipEntry(newDir,
  std::string(),
  FsZip::getFuncs());
  if (ZipReader::readArchiveInfo(entry) == false)
  {
  delete entry;
  return false;
  }
  
  logger->log("Add virtual zip: " + newDir);
  addEntry(entry, append);
  return true;
  }

References addEntry(), Files::existsLocal(), findLast(), VirtFs::FsZip::getFuncs(), Logger::log(), logger, prepareFsPath(), VirtFs::ZipReader::readArchiveInfo(), reportAlways, reportNonTests, and searchByRootInternal().

Referenced by UpdaterWindow::addUpdateFile(), UpdaterWindow::loadManaPlusUpdates(), UpdaterWindow::loadMods(), Dirs::mountDataDir(), and searchAndAddArchives().

◆ mountZip2()

bool VirtFs::mountZip2	(	std::string	newDir,
		std::string	subDir,
		const Append	append
	)

Definition at line 626 of file fs.cpp.

  {
  prepareFsPath(newDir);
  if (Files::existsLocal(newDir) == false)
  {
  reportNonTests("FsZip::mount file not exists: %s",
  newDir.c_str())
  return false;
  }
  if (findLast(newDir, ".zip") == false)
  {
  reportAlways("Called VirtFs::mount without "
  "zip archive")
  return false;
  }
  prepareFsPath(subDir);
  if (subDir == dirSeparator)
  {
  subDir.clear();
  }
  else if (!subDir.empty() &&
  findLast(subDir, std::string(dirSeparator)) == false)
  {
  subDir += dirSeparator;
  }
  if (searchByRootInternal(newDir, subDir) != nullptr)
  {
  reportAlways("FsZip::mount already exists: %s",
  newDir.c_str())
  return false;
  }
  ZipEntry *const entry = new ZipEntry(newDir,
  subDir,
  FsZip::getFuncs());
  if (ZipReader::readArchiveInfo(entry) == false)
  {
  delete entry;
  return false;
  }
  
  logger->log("Add virtual zip: %s with dir %s",
  newDir.c_str(),
  subDir.c_str());
  addEntry(entry, append);
  return true;
  }

References addEntry(), dirSeparator, Files::existsLocal(), findLast(), VirtFs::FsZip::getFuncs(), Logger::log(), logger, prepareFsPath(), VirtFs::ZipReader::readArchiveInfo(), reportAlways, reportNonTests, and searchByRootInternal().

Referenced by Dirs::extractDataDir(), and Dirs::mountDataDir().

◆ openAppend()

File * VirtFs::openAppend ( std::string filename )

Definition at line 312 of file fs.cpp.

  {
  prepareFsPath(filename);
  if (checkPath(filename) == false)
  {
  reportAlways("VirtFs::openAppend invalid path: %s",
  filename.c_str())
  return nullptr;
  }
  FOR_EACH (STD_VECTOR<FsEntry*>::const_iterator, it, mEntries)
  {
  FsEntry *const entry = *it;
  File *const file = entry->funcs->openAppend(entry, filename);
  if (file != nullptr)
  return file;
  }
  return nullptr;
  }

References checkPath(), FOR_EACH, VirtFs::FsEntry::funcs, VirtFs::anonymous_namespace{fs.cpp}::mEntries, VirtFs::FsFuncs::openAppend, prepareFsPath(), and reportAlways.

Referenced by rwopsOpenAppend().

◆ openRead()

File * VirtFs::openRead ( std::string filename )

Definition at line 274 of file fs.cpp.

  {
  prepareFsPath(filename);
  if (checkPath(filename) == false)
  {
  reportAlways("VirtFs::openRead invalid path: %s",
  filename.c_str())
  return nullptr;
  }
  FOR_EACH (STD_VECTOR<FsEntry*>::const_iterator, it, mEntries)
  {
  FsEntry *const entry = *it;
  File *const file = entry->funcs->openRead(entry, filename);
  if (file != nullptr)
  return file;
  }
  return nullptr;
  }

References checkPath(), FOR_EACH, VirtFs::FsEntry::funcs, VirtFs::anonymous_namespace{fs.cpp}::mEntries, VirtFs::FsFuncs::openRead, prepareFsPath(), and reportAlways.

Referenced by rwopsOpenRead().

◆ openWrite()

File * VirtFs::openWrite ( std::string filename )

Definition at line 293 of file fs.cpp.

  {
  prepareFsPath(filename);
  if (checkPath(filename) == false)
  {
  reportAlways("VirtFs::openWrite invalid path: %s",
  filename.c_str())
  return nullptr;
  }
  FOR_EACH (STD_VECTOR<FsEntry*>::const_iterator, it, mEntries)
  {
  FsEntry *const entry = *it;
  File *const file = entry->funcs->openWrite(entry, filename);
  if (file != nullptr)
  return file;
  }
  return nullptr;
  }

References checkPath(), FOR_EACH, VirtFs::FsEntry::funcs, VirtFs::anonymous_namespace{fs.cpp}::mEntries, VirtFs::FsFuncs::openWrite, prepareFsPath(), and reportAlways.

Referenced by rwopsOpenWrite().

◆ permitLinks()

void VirtFs::permitLinks ( const bool val )

Definition at line 803 of file fs.cpp.

  {
  FsDir::permitLinks(val);
  }

References VirtFs::FsDir::permitLinks().

Referenced by Theme::fillFontsList().

◆ read()

int64_t VirtFs::read	(	File *const	file,
		void *const	buffer,
		const uint32_t	objSize,
		const uint32_t	objCount
	)

Definition at line 815 of file fs.cpp.

  {
  return file->funcs->read(file,
  buffer,
  objSize,
  objCount);
  }

Referenced by Net::Download::fadler32().

◆ remove()

bool VirtFs::remove ( const std::string & filename )

Definition at line 780 of file fs.cpp.

  {
  return FsDir::remove(filename);
  }

References VirtFs::FsDir::remove().

Referenced by ConfigManager::backupConfig(), Files::deleteFilesInDirectory(), Net::Download::downloadThread(), Configuration::removeListeners(), and Files::renameFile().

◆ rwopsOpenAppend()

SDL_RWops * VirtFs::rwopsOpenAppend ( const std::string & fname )

Definition at line 143 of file rwops.cpp.

 {
 #ifdef __APPLE__
  if (!checkFilePath(fname))
  return nullptr;
 #endif // __APPLE__
  
  return create_rwops(openAppend(fname),
  fname);
 } /* RWopsopenAppend */

References create_rwops(), and openAppend().

◆ rwopsOpenRead()

SDL_RWops * VirtFs::rwopsOpenRead ( const std::string & fname )

Definition at line 107 of file rwops.cpp.

 {
  BLOCK_START("RWopsopenRead")
 #ifdef __APPLE__
  if (!checkFilePath(fname))
  return nullptr;
 #endif // __APPLE__
 #ifdef USE_FUZZER
  if (Fuzzer::conditionTerminate(fname))
  return nullptr;
 #endif // USE_FUZZER
 #ifdef USE_PROFILER
  
  SDL_RWops *const ret = create_rwops(openRead(fname),
  fname);
  
  BLOCK_END("RWopsopenRead")
  return ret;
 #else // USE_PROFILER
  
  return create_rwops(openRead(fname),
  fname);
 #endif // USE_PROFILER
 } /* RWopsopenRead */

References BLOCK_END, BLOCK_START, create_rwops(), and openRead().

Referenced by anonymous_namespace{imageloader.cpp}::DyedImageLoader::load(), anonymous_namespace{musicloader.cpp}::ResourceLoader::load(), anonymous_namespace{soundloader.cpp}::ResourceLoader::load(), AtlasManager::loadImages(), and Font::openFont().

◆ rwopsOpenWrite()

SDL_RWops * VirtFs::rwopsOpenWrite ( const std::string & fname )

Definition at line 132 of file rwops.cpp.

 {
 #ifdef __APPLE__
  if (!checkFilePath(fname))
  return nullptr;
 #endif // __APPLE__
  
  return create_rwops(openWrite(fname),
  fname);
 } /* RWopsopenWrite */

References create_rwops(), and openWrite().

◆ searchAndAddArchives()

void VirtFs::searchAndAddArchives	(	const std::string &	path,
		const std::string &	ext,
		const Append	append
	)

Definition at line 41 of file tools.cpp.

  {
  List *const list = VirtFs::enumerateFiles(path);
  FOR_EACH (StringVectCIter, i, list->names)
  {
  const std::string str = *i;
  const size_t len = str.size();
  
  if (len > ext.length() &&
  ext == str.substr(len - ext.length()))
  {
  const std::string file = path + str;
  const std::string realPath = VirtFs::getRealDir(file);
  VirtFs::mountZip(pathJoin(realPath, file), append);
  }
  }
  VirtFs::freeList(list);
  }

References enumerateFiles(), FOR_EACH, freeList(), getRealDir(), mountZip(), VirtFs::List::names, and pathJoin().

Referenced by Client::gameExec(), and Client::loadData().

◆ searchAndRemoveArchives()

void VirtFs::searchAndRemoveArchives	(	const std::string &	path,
		const std::string &	ext
	)

Definition at line 62 of file tools.cpp.

  {
  List *const list = VirtFs::enumerateFiles(path);
  FOR_EACH (StringVectCIter, i, list->names)
  {
  const std::string str = *i;
  const size_t len = str.size();
  if (len > ext.length() &&
  ext == str.substr(len - ext.length()))
  {
  const std::string file = path + str;
  const std::string realPath = VirtFs::getRealDir(file);
  VirtFs::unmountZip(pathJoin(realPath, file));
  }
  }
  VirtFs::freeList(list);
  }

References enumerateFiles(), FOR_EACH, freeList(), getRealDir(), VirtFs::List::names, pathJoin(), and unmountZip().

Referenced by Client::unloadData().

◆ searchByRootInternal()

FsEntry * VirtFs::searchByRootInternal	(	const std::string &	root,
		const std::string &	subDir
	)

Definition at line 94 of file fs.cpp.

  {
  FOR_EACH (STD_VECTOR<FsEntry*>::const_iterator, it, mEntries)
  {
  const FsEntry *const entry = *it;
  if (entry->root == root &&
  entry->subDir == subDir)
  {
  return *it;
  }
  }
  return nullptr;
  }

References FOR_EACH, VirtFs::anonymous_namespace{fs.cpp}::mEntries, VirtFs::FsEntry::root, and VirtFs::FsEntry::subDir.

Referenced by mountDirInternal(), mountZip(), and mountZip2().

◆ searchByTypeInternal()

FsEntry * VirtFs::searchByTypeInternal	(	const std::string &	root,
		const FsEntryTypeT	type
	)

Definition at line 109 of file fs.cpp.

  {
  FOR_EACH (STD_VECTOR<FsEntry*>::const_iterator, it, mEntries)
  {
  const FsEntry *const entry = *it;
  if (entry->root == root &&
  entry->type == type)
  {
  return *it;
  }
  }
  return nullptr;
  }

References FOR_EACH, VirtFs::anonymous_namespace{fs.cpp}::mEntries, VirtFs::FsEntry::root, and VirtFs::FsEntry::type.

◆ seek()

int VirtFs::seek	(	File *const	file,
		const uint64_t	pos
	)

Definition at line 847 of file fs.cpp.

  {
  return file->funcs->seek(file,
  pos);
  }

Referenced by TextManager::place().

◆ setWriteDir()

bool VirtFs::setWriteDir ( const std::string & newDir )

Definition at line 331 of file fs.cpp.

  {
  return FsDir::setWriteDir(newDir);
  }

References VirtFs::FsDir::setWriteDir().

Referenced by Client::gameInit(), and main().

◆ tell()

int64_t VirtFs::tell ( File *const file )

Definition at line 842 of file fs.cpp.

  {
  return file->funcs->tell(file);
  }

◆ unmountDir()

bool VirtFs::unmountDir ( std::string oldDir )

Definition at line 518 of file fs.cpp.

  {
  prepareFsPath(oldDir);
  if (oldDir.find(".zip") != std::string::npos)
  {
  reportAlways("Called unmount with zip archive")
  return false;
  }
  if (unmountDirInternal(oldDir, std::string()) == false)
  {
  reportAlways("VirtFs::unmountDir not exists: %s",
  oldDir.c_str())
  return false;
  }
  return true;
  }

References prepareFsPath(), reportAlways, and unmountDirInternal().

Referenced by UpdaterWindow::unloadMods().

◆ unmountDir2()

bool VirtFs::unmountDir2	(	std::string	oldDir,
		std::string	subDir
	)

Definition at line 535 of file fs.cpp.

  {
  prepareFsPath(oldDir);
  if (oldDir.find(".zip") != std::string::npos)
  {
  reportAlways("Called unmount with zip archive")
  return false;
  }
  prepareFsPath(subDir);
  if (unmountDirInternal(oldDir, subDir) == false)
  {
  reportAlways("VirtFs::unmountDir not exists: %s",
  oldDir.c_str())
  return false;
  }
  return true;
  }

References prepareFsPath(), reportAlways, and unmountDirInternal().

◆ unmountDirInternal()

bool VirtFs::unmountDirInternal	(	std::string	oldDir,
		std::string	subDir
	)

Definition at line 477 of file fs.cpp.

  {
  if (findLast(oldDir, std::string(dirSeparator)) == false)
  oldDir += dirSeparator;
  if (subDir == dirSeparator)
  {
  subDir.clear();
  }
  else if (!subDir.empty() &&
  findLast(subDir, std::string(dirSeparator)) == false)
  {
  subDir += dirSeparator;
  }
  FOR_EACH (STD_VECTOR<FsEntry*>::iterator, it, mEntries)
  {
  FsEntry *const entry = *it;
  if (entry->root == oldDir &&
  entry->type == FsEntryType::Dir &&
  entry->subDir == subDir)
  {
  DirEntry *const dirEntry = static_cast<DirEntry*>(
  entry);
  if (subDir.empty())
  {
  logger->log("Remove virtual directory: " + oldDir);
  }
  else
  {
  logger->log("Remove virtual directory: %s with dir %s",
  oldDir.c_str(),
  subDir.c_str());
  }
  mEntries.erase(it);
  delete dirEntry;
  return true;
  }
  }
  return false;
  }

References FsEntryType::Dir, dirSeparator, findLast(), FOR_EACH, Logger::log(), logger, VirtFs::anonymous_namespace{fs.cpp}::mEntries, VirtFs::FsEntry::root, VirtFs::FsEntry::subDir, and VirtFs::FsEntry::type.

Referenced by unmountDir(), unmountDir2(), unmountDirSilent(), and unmountDirSilent2().

◆ unmountDirSilent()

bool VirtFs::unmountDirSilent ( std::string oldDir )

Definition at line 554 of file fs.cpp.

  {
  prepareFsPath(oldDir);
  if (oldDir.find(".zip") != std::string::npos)
  {
  reportAlways("Called unmount with zip archive")
  return false;
  }
  if (unmountDirInternal(oldDir, std::string()) == false)
  {
  logger->log("VirtFs::unmountDir not exists: %s",
  oldDir.c_str());
  return false;
  }
  return true;
  }

References Logger::log(), logger, prepareFsPath(), reportAlways, and unmountDirInternal().