janwas
a859562ea7
- properly differentiate between buffer/offset alignment and length alignment (relevant since block size has been increased to 256k) - use VfsPath for most game paths instead of CStr - clean up timer interface and implementation - self-tests no longer crash - file_cache.cpp: fix for the case where allocation fails (prevent deleter from seeing a null pointer) - allocators: move all shared_ptr-related stuff to its own component; add DummySharedPtr - codec: disable checksums (important for performance at work) - File: made into an interface class to avoid export problems. not entirely sure about this.. - vfs_path.h, path.h, os_path.h: proper fix for using fs::change_extension and similar utility functions with derivatives of basic_path - lib_api: automatically link against import lib if building lib/ as a DLL - path_util: remove unused functions (this component is deprecated) - compiler.h: add INLINE - Xeromyces.cpp: pass PIVFS so that GetXMBPath works in self-test (should do this mostly everywhere rather than have one singleton g_VFS) This was SVN commit r5537.
143 lines
4.2 KiB
C++
143 lines
4.2 KiB
C++
/**
|
|
* =========================================================================
|
|
* File : file_system_util.cpp
|
|
* Project : 0 A.D.
|
|
* Description : helper functions for directory access
|
|
* =========================================================================
|
|
*/
|
|
|
|
// license: GPL; see lib/license.txt
|
|
|
|
#include "precompiled.h"
|
|
#include "file_system_util.h"
|
|
|
|
#include <queue>
|
|
#include <cstring>
|
|
|
|
#include "lib/path_util.h"
|
|
#include "lib/regex.h"
|
|
|
|
LibError fs_GetPathnames(PIVFS fs, const VfsPath& path, const char* filter, VfsPaths& pathnames)
|
|
{
|
|
std::vector<FileInfo> files;
|
|
RETURN_ERR(fs->GetDirectoryEntries(path, &files, 0));
|
|
|
|
pathnames.clear();
|
|
pathnames.reserve(files.size());
|
|
|
|
for(size_t i = 0; i < files.size(); i++)
|
|
{
|
|
if(match_wildcard(files[i].Name().c_str(), filter))
|
|
pathnames.push_back(path/files[i].Name());
|
|
}
|
|
|
|
return INFO::OK;
|
|
}
|
|
|
|
|
|
struct FileInfoNameLess : public std::binary_function<const FileInfo, const FileInfo, bool>
|
|
{
|
|
bool operator()(const FileInfo& fileInfo1, const FileInfo& fileInfo2) const
|
|
{
|
|
return strcasecmp(fileInfo1.Name().c_str(), fileInfo2.Name().c_str()) < 0;
|
|
}
|
|
};
|
|
|
|
void fs_SortFiles(FileInfos& files)
|
|
{
|
|
std::sort(files.begin(), files.end(), FileInfoNameLess());
|
|
}
|
|
|
|
|
|
struct NameLess : public std::binary_function<const std::string, const std::string, bool>
|
|
{
|
|
bool operator()(const std::string& name1, const std::string& name2) const
|
|
{
|
|
return strcasecmp(name1.c_str(), name2.c_str()) < 0;
|
|
}
|
|
};
|
|
|
|
void fs_SortDirectories(DirectoryNames& directories)
|
|
{
|
|
std::sort(directories.begin(), directories.end(), NameLess());
|
|
}
|
|
|
|
|
|
LibError fs_ForEachFile(PIVFS fs, const VfsPath& path, FileCallback cb, uintptr_t cbData, const char* pattern, unsigned flags)
|
|
{
|
|
debug_assert(vfs_path_IsDirectory(path));
|
|
|
|
// (declare here to avoid reallocations)
|
|
FileInfos files; DirectoryNames subdirectoryNames;
|
|
|
|
// (a FIFO queue is more efficient than recursion because it uses less
|
|
// stack space and avoids seeks due to breadth-first traversal.)
|
|
std::queue<VfsPath> pendingDirectories;
|
|
pendingDirectories.push(path);
|
|
while(!pendingDirectories.empty())
|
|
{
|
|
const VfsPath& path = pendingDirectories.front();
|
|
|
|
RETURN_ERR(fs->GetDirectoryEntries(path/"/", &files, &subdirectoryNames));
|
|
|
|
for(size_t i = 0; i < files.size(); i++)
|
|
{
|
|
const FileInfo fileInfo = files[i];
|
|
if(!match_wildcard(fileInfo.Name().c_str(), pattern))
|
|
continue;
|
|
|
|
const VfsPath pathname(path/fileInfo.Name()); // (FileInfo only stores the name)
|
|
cb(pathname, fileInfo, cbData);
|
|
}
|
|
|
|
if(!(flags & DIR_RECURSIVE))
|
|
break;
|
|
|
|
for(size_t i = 0; i < subdirectoryNames.size(); i++)
|
|
pendingDirectories.push(path/subdirectoryNames[i]);
|
|
pendingDirectories.pop();
|
|
}
|
|
|
|
return INFO::OK;
|
|
}
|
|
|
|
|
|
void fs_NextNumberedFilename(PIVFS fs, const VfsPath& pathnameFormat, unsigned& nextNumber, VfsPath& nextPathname)
|
|
{
|
|
// (first call only:) scan directory and set nextNumber according to
|
|
// highest matching filename found. this avoids filling "holes" in
|
|
// the number series due to deleted files, which could be confusing.
|
|
// example: add 1st and 2nd; [exit] delete 1st; [restart]
|
|
// add 3rd -> without this measure it would get number 1, not 3.
|
|
if(nextNumber == 0)
|
|
{
|
|
const std::string nameFormat = pathnameFormat.leaf();
|
|
const VfsPath path = pathnameFormat.branch_path();
|
|
|
|
unsigned maxNumber = 0;
|
|
FileInfos files;
|
|
fs->GetDirectoryEntries(path, &files, 0);
|
|
for(size_t i = 0; i < files.size(); i++)
|
|
{
|
|
unsigned number;
|
|
if(sscanf(files[i].Name().c_str(), nameFormat.c_str(), &number) == 1)
|
|
maxNumber = std::max(number, maxNumber);
|
|
}
|
|
|
|
nextNumber = maxNumber+1;
|
|
}
|
|
|
|
// now increment number until that file doesn't yet exist.
|
|
// this is fairly slow, but typically only happens once due
|
|
// to scan loop above. (we still need to provide for looping since
|
|
// someone may have added files in the meantime)
|
|
// we don't bother with binary search - this isn't a bottleneck.
|
|
do
|
|
{
|
|
char pathnameBuf[PATH_MAX];
|
|
snprintf(pathnameBuf, PATH_MAX, pathnameFormat.string().c_str(), nextNumber++);
|
|
nextPathname = VfsPath(pathnameBuf);
|
|
}
|
|
while(fs->GetFileInfo(nextPathname, 0) == INFO::OK);
|
|
}
|