VirtFs Namespace Reference

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().

Referenced by Client::unloadData().

unmountDirSilent2()

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

Definition at line 571 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)
        {
            logger->log("VirtFs::unmountDir not exists: %s",
                oldDir.c_str());
            return false;
        }
        return true;
    }

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

unmountZip()

bool VirtFs::unmountZip

(

std::string

oldDir

)

Definition at line 675 of file fs.cpp.

    {
        prepareFsPath(oldDir);
        if (findLast(oldDir, ".zip") == false)
        {
            reportAlways("Called unmount without zip archive")
            return false;
        }
        FOR_EACH (STD_VECTOR<FsEntry*>::iterator, it, mEntries)
        {
            FsEntry *const entry = *it;
            if (entry->root == oldDir &&
                entry->type == FsEntryType::Zip &&
                entry->subDir.empty())
            {
                ZipEntry *const zipEntry = static_cast<ZipEntry*>(
                    entry);
                logger->log("Remove virtual zip: " + oldDir);
                mEntries.erase(it);
                delete zipEntry;
                return true;
            }
        }
 
        reportAlways("VirtFs::unmountZip not exists: %s",
            oldDir.c_str())
        return false;
    }

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

Referenced by UpdaterWindow::removeUpdateFile(), searchAndRemoveArchives(), and UpdaterWindow::unloadManaPlusUpdates().

unmountZip2()

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

Definition at line 704 of file fs.cpp.

    {
        prepareFsPath(oldDir);
        if (findLast(oldDir, ".zip") == false)
        {
            reportAlways("Called unmount without zip archive")
            return false;
        }
        prepareFsPath(subDir);
        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::Zip &&
                entry->subDir == subDir)
            {
                ZipEntry *const zipEntry = static_cast<ZipEntry*>(
                    entry);
                logger->log("Remove virtual zip: %s with dir %s",
                    oldDir.c_str(),
                    subDir.c_str());
                mEntries.erase(it);
                delete zipEntry;
                return true;
            }
        }
 
        reportAlways("VirtFs::unmountZip not exists: %s",
            oldDir.c_str())
        return false;
    }

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

updateDirSeparator()

void VirtFs::updateDirSeparator

(

)

Definition at line 65 of file fs.cpp.

    {
#ifdef WIN32
        dirSeparator = "\\";
#else  // WIN32
        dirSeparator = "/";
#endif  // WIN32
    }

References dirSeparator.

Referenced by init().

write()

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

Definition at line 826 of file fs.cpp.

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

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