FileNodeRef FileSystemRedirect::create(const Path& path,FileNode::Mode mode) { Path p = _merge(path); FileSystemRef fs = mMFS->getFileSystem(p); if (fs != NULL) return fs->create(p,mode); return NULL; }
Path FileSystemRedirect::mapFrom(const Path& path) { Path p = _merge(path); FileSystemRef fs = mMFS->getFileSystem(p); if (fs != NULL) return fs->mapFrom(p); return NULL; }
bool FileSystemRedirect::remove(const Path& path) { Path p = _merge(path); FileSystemRef fs = mMFS->getFileSystem(p); if (fs != NULL) return fs->remove(p); return false; }
FileNodeRef FileSystemRedirect::resolve(const Path& path) { Path p = _merge(path); FileSystemRef fs = mMFS->getFileSystem(p); if (fs != NULL) return fs->resolve(p); return NULL; }
FileNodeRef MountSystem::getFileNode(const Path& path) { Path np = _normalize(path); FileSystemRef fs = _getFileSystemFromList(np); if (fs != NULL) return fs->resolve(np); return NULL; }
/// Makes sure paths going in and out of the notifier will have the same format String FileSystemChangeNotifier::cleanPath(const Path& dir) { // This "cleans up" the path, if we don't do this we can get mismatches on the path // coming from the notifier FileSystemRef fs = Torque::FS::GetFileSystem(dir); if (!fs) return String::EmptyString; return fs->mapFrom(fs->mapTo(dir)); }
bool FileSystemRedirect::rename(const Path& a,const Path& b) { Path na = _merge(a); Path nb = _merge(b); FileSystemRef fsa = mMFS->getFileSystem(na); FileSystemRef fsb = mMFS->getFileSystem(nb); if (fsa.getPointer() == fsb.getPointer()) return fsa->rename(na,nb); return false; }
bool GetFSPath( const Path &inPath, Path &outPath ) { FileSystemRef sys = GetFileSystem( inPath ); if ( sys ) { outPath = sys->mapTo( inPath ); return true; } return false; }
bool FileSystemRedirectChangeNotifier::removeNotification( const Path &path, ChangeDelegate callback ) { FileSystemRedirect *rfs = (FileSystemRedirect*)mFS; Path redirectPath = rfs->_merge( path ); FileSystemRef fs = rfs->mMFS->getFileSystem( redirectPath ); if ( !fs || !fs->getChangeNotifier() ) return false; return fs->getChangeNotifier()->removeNotification( redirectPath, callback ); }
bool MountSystem::remove(const Path& path) { Path np = _normalize(path); FileSystemRef fs = _getFileSystemFromList(np); if (fs && fs->isReadOnly()) { _log(String::ToString("Cannot remove path %s, filesystem is read-only", path.getFullPath().c_str())); return false; } if (fs != NULL) return fs->remove(np); return false; }
bool MountSystem::mapFSPath( const String &inRoot, const Path &inPath, Path &outPath ) { FileSystemRef fs = _getFileSystemFromList(inRoot); if ( fs == NULL ) { outPath = Path(); return false; } outPath = fs->mapFrom( inPath ); return outPath.getFullPath() != String(); }
FileRef MountSystem::createFile(const Path& path) { Path np = _normalize(path); FileSystemRef fs = _getFileSystemFromList(np); if (fs && fs->isReadOnly()) { _log(String::ToString("Cannot create file %s, filesystem is read-only", path.getFullPath().c_str())); return NULL; } if (fs != NULL) return static_cast<File*>(fs->create(np,FileNode::File).getPointer()); return NULL; }
DirectoryRef MountSystem::createDirectory(const Path& path, FileSystemRef fs) { Path np = _normalize(path); if (fs.isNull()) fs = _getFileSystemFromList(np); if (fs && fs->isReadOnly()) { _log(String::ToString("Cannot create directory %s, filesystem is read-only", path.getFullPath().c_str())); return NULL; } if (fs != NULL) return static_cast<Directory*>(fs->create(np,FileNode::Directory).getPointer()); return NULL; }
bool MountSystem::isReadOnly(const Path& path) { // first check to see if filesystem is read only FileSystemRef fs = getFileSystem(path); if ( fs.isNull() ) // no filesystem owns this file...oh well, return false return false; if (fs->isReadOnly()) return true; // check the file attributes, note that if the file does not exist, // this function returns false. that should be ok since we know // the file system is writable at this point. FileNode::Attributes attr; if (getFileAttributes(path,&attr)) return attr.flags & FileNode::ReadOnly; return false; }
bool MountSystem::unmount(FileSystemRef fs) { if (fs.isNull()) return false; // iterate back to front in case FS is in list multiple times. // also check that fs is not null each time since its a strong ref // so it could be nulled during removal. bool unmounted = false; for (S32 i = mMountList.size() - 1; !fs.isNull() && i >= 0; --i) { if (mMountList[i].fileSystem.getPointer() == fs.getPointer()) { mMountList.erase(i); unmounted = true; } } return unmounted; }
bool MountSystem::isDirectory(const Path& path, FileSystemRef fsRef) { FileNode::Attributes attr; if (fsRef.isNull()) { if (getFileAttributes(path,&attr)) return attr.flags & FileNode::Directory; return false; } else { FileNodeRef fnRef = fsRef->resolve(path); if (fnRef.isNull()) return false; FileNode::Attributes attr; if (fnRef->getAttributes(&attr)) return attr.flags & FileNode::Directory; return false; } }
bool MountSystem::rename(const Path& from,const Path& to) { // Will only rename files on the same filesystem Path pa = _normalize(from); Path pb = _normalize(to); FileSystemRef fsa = _getFileSystemFromList(pa); FileSystemRef fsb = _getFileSystemFromList(pb); if (!fsa || !fsb) return false; if (fsa.getPointer() != fsb.getPointer()) { _log(String::ToString("Cannot rename path %s to a different filesystem", from.getFullPath().c_str())); return false; } if (fsa->isReadOnly() || fsb->isReadOnly()) { _log(String::ToString("Cannot rename path %s; source or target filesystem is read-only", from.getFullPath().c_str())); return false; } return fsa->rename(pa,pb); }
bool VirtualMountSystem::unmount(FileSystemRef fs) { bool unmounted = Parent::unmount(fs); if (!unmounted) return false; // this is a linear time operation, because we have to search every path in all roots // to remove references to the fs. // contant time operation can be achieved be using the unmount(string) version, which unmounts all // filesystems for a given root and so doesn't need to do any searching. U32 start = Platform::GetPlatform()->getRealMilliseconds(); for (RootToPathFSMap::Iterator riter = mMountMap.begin(); riter != mMountMap.end(); ++riter) { PathFSMap* rootDict = (*riter).value; for (PathFSMap::Iterator piter = rootDict->begin(); piter != rootDict->end(); ++piter) { Vector<FileSystemRef>& plist = (*piter).value; for (S32 i = plist.size() - 1; i >= 0; i--) { if (plist[i].getPointer() == fs.getPointer()) plist.erase(i); } } } if (gVMSVerboseLog) _log(String::ToString("Unmounted virtual file system in %ums", Platform::GetPlatform()->getRealMilliseconds() - start)); return true; }