mirror of
https://github.com/AquariaOSE/Aquaria.git
synced 2024-11-29 03:33:48 +00:00
377 lines
9.7 KiB
C++
377 lines
9.7 KiB
C++
// Dir.cpp - basic directory interface + classes
|
|
// For conditions of distribution and use, see copyright notice in VFS.h
|
|
|
|
#include <set>
|
|
|
|
#include "VFSInternal.h"
|
|
#include "VFSTools.h"
|
|
#include "VFSFile.h"
|
|
#include "VFSDir.h"
|
|
#include "VFSDirView.h"
|
|
#include "VFSLoader.h"
|
|
|
|
//#include <stdio.h>
|
|
|
|
VFS_NAMESPACE_START
|
|
|
|
DirBase::DirBase(const char *fullpath)
|
|
{
|
|
_setName(fullpath);
|
|
}
|
|
|
|
DirBase::~DirBase()
|
|
{
|
|
}
|
|
|
|
File *DirBase::getFile(const char *fn)
|
|
{
|
|
while(fn[0] == '.' && fn[1] == '/')
|
|
fn += 2;
|
|
|
|
const char *slashpos = strchr(fn, '/');
|
|
if(!slashpos)
|
|
return getFileByName(fn, true);
|
|
|
|
size_t copysize = std::max<size_t>(slashpos - fn, 1); // always copy the '/' if it's the first char
|
|
char * const dirname = (char*)VFS_STACK_ALLOC(copysize + 1);
|
|
memcpy(dirname, fn, copysize);
|
|
dirname[copysize] = 0;
|
|
|
|
File *f = getFileFromSubdir(dirname, slashpos + 1);
|
|
VFS_STACK_FREE(dirname);
|
|
return f;
|
|
}
|
|
|
|
DirBase *DirBase::getDir(const char *subdir)
|
|
{
|
|
// TODO: get rid of alloc
|
|
std::string fullpath = joinPath(fullname(), subdir);
|
|
return _getDirEx(subdir, fullpath.c_str(), false, true, true).first;
|
|
}
|
|
|
|
// returns requested subdir or NULL as first, and last existing subdir in the tree as second.
|
|
std::pair<DirBase*, DirBase*> DirBase::_getDirEx(const char *subdir, const char * const fullpath,
|
|
bool forceCreate /* = false */, bool lazyLoad /* = true */, bool useSubtrees /* = true */)
|
|
{
|
|
//printf("DirBase::_getDirEx [%s] in [%s]\n", subdir, fullname());
|
|
SkipSelfPath(subdir);
|
|
if(!subdir[0])
|
|
return std::make_pair(this, this);
|
|
|
|
DirBase *ret = NULL;
|
|
DirBase *last = NULL;
|
|
char *slashpos = (char *)strchr(subdir, '/');
|
|
|
|
// if there is a '/' in the string, descend into subdir and continue there
|
|
if(slashpos)
|
|
{
|
|
// from a/b/c, cut out the a, without the trailing '/'.
|
|
const char *sub = slashpos + 1;
|
|
size_t copysize = std::max<size_t>(slashpos - subdir, 1); // always copy the '/' if it's the first char
|
|
char * const t = (char*)VFS_STACK_ALLOC(copysize + 1);
|
|
memcpy(t, subdir, copysize);
|
|
t[copysize] = 0;
|
|
|
|
if(DirBase *dir = getDirByName(t, lazyLoad, useSubtrees))
|
|
{
|
|
std::pair<DirBase*, DirBase*> subpair = dir->_getDirEx(sub, fullpath, forceCreate, lazyLoad); // descend into subdirs
|
|
ret = subpair.first;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if(DirBase *dir = getDirByName(subdir, lazyLoad, useSubtrees))
|
|
ret = dir;
|
|
}
|
|
|
|
if(forceCreate && !ret)
|
|
ret = _createAndInsertSubtree(subdir);
|
|
|
|
return std::make_pair(ret, this);
|
|
}
|
|
|
|
DirBase *DirBase::_createAndInsertSubtree(const char *subdir)
|
|
{
|
|
size_t subdirLen = strlen(subdir);
|
|
char * const buf = (char*)VFS_STACK_ALLOC(subdirLen + 2);
|
|
buf[0] = '/';
|
|
memcpy(buf+1, subdir, subdirLen + 1); //copy terminating \0 too
|
|
char *s = buf+1;
|
|
|
|
DirBase *curdir = this;
|
|
while(*s)
|
|
{
|
|
char *slashpos = strchr(s, '/');
|
|
if(slashpos)
|
|
{
|
|
if(slashpos == buf+1) // only check this in first round
|
|
{
|
|
s = buf;
|
|
//printf("abs buf: [%s]\n", buf);
|
|
}
|
|
*slashpos = 0;
|
|
//printf("_createAndInsertSubtree: [%s]\n", s);
|
|
}
|
|
|
|
DirBase *nextdir = curdir->DirBase::getDirByName(s, false, false); // last 2 params are not relevant
|
|
if(!nextdir)
|
|
nextdir = curdir->_createNewSubdir(s);
|
|
curdir->_subdirs[nextdir->name()] = nextdir;
|
|
curdir = nextdir;
|
|
if(!slashpos)
|
|
break;
|
|
s = slashpos + 1;
|
|
}
|
|
|
|
VFS_STACK_FREE(buf);
|
|
return curdir;
|
|
}
|
|
|
|
DirBase *DirBase::_createNewSubdir(const char *subdir) const
|
|
{
|
|
assert(*subdir);
|
|
//printf("_createNewSubdir: [%s]\n", subdir);
|
|
// -> newname = fullname() + '/' + subdir
|
|
size_t fullLen = fullnameLen();
|
|
size_t subdirLen = strlen(subdir);
|
|
char * const newname = (char*)VFS_STACK_ALLOC(fullLen + subdirLen + 2);
|
|
char *ptr = newname;
|
|
if(fullLen)
|
|
{
|
|
memcpy(ptr, fullname(), fullLen);
|
|
ptr += fullLen;
|
|
if(ptr[-1] != '/')
|
|
*ptr++ = '/';
|
|
}
|
|
|
|
memcpy(ptr, subdir, subdirLen + 1); // copy terminating \0 too
|
|
//printf("_createNewSubdir: newname = [%s]\n", newname);
|
|
DirBase *ret = createNew(newname);
|
|
//printf("_createNewSubdir: fullname = [%s]\n", ret->fullname());
|
|
VFS_STACK_FREE(newname);
|
|
return ret;
|
|
}
|
|
|
|
|
|
|
|
static void _iterDirs(Dirs &m, DirEnumCallback f, void *user)
|
|
{
|
|
for(Dirs::iterator it = m.begin(); it != m.end(); ++it)
|
|
f(it->second.content(), user);
|
|
}
|
|
|
|
void DirBase::forEachDir(DirEnumCallback f, void *user /* = NULL */, bool safe /* = false */)
|
|
{
|
|
if(safe)
|
|
{
|
|
Dirs cp = _subdirs;
|
|
_iterDirs(cp, f, user);
|
|
}
|
|
else
|
|
_iterDirs(_subdirs, f, user);
|
|
}
|
|
|
|
DirBase *DirBase::getDirByName(const char *dn, bool /* unused: lazyLoad = true */, bool useSubtrees /* = true */)
|
|
{
|
|
if(!dn[0] || (dn[0] == '.' && !dn[1]))
|
|
return this;
|
|
|
|
Dirs::iterator it = _subdirs.find(dn);
|
|
return it != _subdirs.end() ? it->second : NULL;
|
|
}
|
|
|
|
void DirBase::clearGarbage()
|
|
{
|
|
for(Dirs::iterator it = _subdirs.begin(); it != _subdirs.end(); ++it)
|
|
it->second->clearGarbage();
|
|
}
|
|
|
|
|
|
|
|
Dir::Dir(const char *fullpath, VFSLoader *ldr)
|
|
: DirBase(fullpath), _loader(ldr)
|
|
{
|
|
}
|
|
|
|
Dir::~Dir()
|
|
{
|
|
}
|
|
|
|
File *Dir::getFileByName(const char *fn, bool lazyLoad /* = true */)
|
|
{
|
|
Files::iterator it = _files.find(fn);
|
|
if(it != _files.end())
|
|
return it->second;
|
|
|
|
if(!lazyLoad || !_loader)
|
|
return NULL;
|
|
|
|
// Lazy-load file if it's not in the tree yet
|
|
std::string fn2 = joinPath(fullname(), GetBaseNameFromPath(fn));
|
|
File *f = _loader->Load(fn2.c_str(), fn2.c_str());
|
|
if(f)
|
|
_files[f->name()] = f;
|
|
return f;
|
|
}
|
|
|
|
static void _iterFiles(Files &m, FileEnumCallback f, void *user)
|
|
{
|
|
for(Files::iterator it = m.begin(); it != m.end(); ++it)
|
|
f(it->second.content(), user);
|
|
}
|
|
|
|
void Dir::forEachFile(FileEnumCallback f, void *user /* = NULL */, bool safe /* = false */)
|
|
{
|
|
load();
|
|
if(safe)
|
|
{
|
|
Files cp = _files;
|
|
_iterFiles(cp, f, user);
|
|
}
|
|
else
|
|
_iterFiles(_files, f, user);
|
|
}
|
|
|
|
void Dir::forEachDir(DirEnumCallback f, void *user /* = NULL */, bool safe /* = false */)
|
|
{
|
|
load();
|
|
DirBase::forEachDir(f, user, safe);
|
|
}
|
|
|
|
|
|
|
|
bool Dir::add(File *f)
|
|
{
|
|
if(!f)
|
|
return false;
|
|
|
|
Files::iterator it = _files.find(f->name());
|
|
|
|
if(it != _files.end())
|
|
{
|
|
File *oldf = it->second;
|
|
if(oldf == f)
|
|
return false;
|
|
|
|
_files.erase(it);
|
|
}
|
|
|
|
_files[f->name()] = f;
|
|
return true;
|
|
}
|
|
|
|
bool Dir::addRecursive(File *f, size_t skip /* = 0 */)
|
|
{
|
|
if(!f)
|
|
return false;
|
|
|
|
Dir *vdir = this;
|
|
if(f->fullnameLen() - f->nameLen() > skip)
|
|
{
|
|
// figure out directory from full file name
|
|
size_t prefixLen = f->fullnameLen() - f->nameLen() - skip;
|
|
|
|
// prefixLen == 0 is invalid, prefixLen == 1 is just a single '/', which will be stripped away below.
|
|
// in both cases, just use 'this'.
|
|
// FIXME: will this be a problem for absolute paths?
|
|
if(prefixLen > 1)
|
|
{
|
|
char *dirname = (char*)VFS_STACK_ALLOC(prefixLen);
|
|
--prefixLen; // -1 to strip the trailing '/'. That's the position where to put the terminating null byte.
|
|
memcpy(dirname, f->fullname() + skip, prefixLen); // copy trailing null byte
|
|
dirname[prefixLen] = 0;
|
|
vdir = safecastNonNull<Dir*>(_getDirEx(dirname, dirname, true, true).first);
|
|
VFS_STACK_FREE(dirname);
|
|
}
|
|
}
|
|
|
|
return vdir->add(f);
|
|
}
|
|
|
|
void Dir::clearGarbage()
|
|
{
|
|
DirBase::clearGarbage();
|
|
for(Files::iterator it = _files.begin(); it != _files.end(); ++it)
|
|
it->second->clearGarbage();
|
|
}
|
|
|
|
bool Dir::_addToView(char *path, DirView& view)
|
|
{
|
|
if(Dir *dir = safecast<Dir*>(getDir(path)))
|
|
{
|
|
view.add(dir);
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
DirBase *Dir::getDirByName(const char *dn, bool lazyLoad /* = true */, bool useSubtrees /* = true */)
|
|
{
|
|
DirBase *sub;
|
|
if((sub = DirBase::getDirByName(dn, lazyLoad, useSubtrees)))
|
|
return sub;
|
|
|
|
if(!lazyLoad || !_loader)
|
|
return NULL;
|
|
|
|
// Fix for absolute paths: No dir should have '/' (or any other absolute dirs) as subdir.
|
|
if(fullnameLen() && dn[0] == '/')
|
|
return NULL;
|
|
|
|
// Lazy-load file if it's not in the tree yet
|
|
// TODO: get rid of alloc
|
|
std::string fn2 = joinPath(fullname(), dn);
|
|
sub = _loader->LoadDir(fn2.c_str(), fn2.c_str());
|
|
if(sub)
|
|
{
|
|
_subdirs[sub->name()] = sub;
|
|
//printf("Lazy loaded: [%s]\n", sub->fullname());
|
|
}
|
|
return sub;
|
|
}
|
|
|
|
File *Dir::getFileFromSubdir(const char *subdir, const char *file)
|
|
{
|
|
Dir *d = safecast<Dir*>(getDirByName(subdir, true, false)); // useSubtrees is irrelevant here
|
|
return d ? d->getFile(file) : NULL;
|
|
}
|
|
|
|
|
|
|
|
// ----- DiskDir start here -----
|
|
|
|
|
|
DiskDir::DiskDir(const char *path, VFSLoader *ldr) : Dir(path, ldr)
|
|
{
|
|
}
|
|
|
|
DiskDir *DiskDir::createNew(const char *dir) const
|
|
{
|
|
return new DiskDir(dir, getLoader());
|
|
}
|
|
|
|
void DiskDir::load()
|
|
{
|
|
_files.clear();
|
|
_subdirs.clear();
|
|
// TODO: cache existing files and keep them unless they do no longer exist
|
|
|
|
StringList li;
|
|
GetFileList(fullname(), li);
|
|
for(StringList::iterator it = li.begin(); it != li.end(); ++it)
|
|
{
|
|
DiskFile *f = new DiskFile(joinPath(fullname(), it->c_str()).c_str());
|
|
_files[f->name()] = f;
|
|
}
|
|
|
|
li.clear();
|
|
GetDirList(fullname(), li, 0);
|
|
for(StringList::iterator it = li.begin(); it != li.end(); ++it)
|
|
{
|
|
// GetDirList() returns relative paths, so need to join
|
|
Dir *d = createNew(joinPath(fullname(), it->c_str()).c_str());
|
|
_subdirs[d->name()] = d;
|
|
}
|
|
}
|
|
|
|
VFS_NAMESPACE_END
|