vfs.h

Go to the documentation of this file.

 
 
 
#pragma once
 
#include <cx/fs/file.h>
#include <cx/fs/fs.h>
#include <cx/time/time.h>
#include <cx/fs/vfsfile.h>
#include <cx/fs/vfsobj.h>
#include <cx/fs/vfsprovider.h>
 
typedef struct VFS VFS;
 
CX_C_BEGIN
 
_At_(*pvfs, _Pre_maybenull_ _Post_null_) void vfsDestroy(VFS** pvfs);
 
bool vfsUnmount(_Inout_ VFS* vfs, _In_opt_ strref path);
 
bool _vfsMountProvider(_Inout_ VFS* vfs, _Inout_ ObjInst* provider, _In_opt_ strref path,
                       flags_t flags);
 
#define vfsMountProvider(vfs, provider, path, ...) \
    _vfsMountProvider(vfs, objInstBase(provider), path, opt_flags(__VA_ARGS__))
 
bool _vfsMountFS(_Inout_ VFS* vfs, _In_opt_ strref path, _In_opt_ strref fsroot, flags_t flags);
 
#define vfsMountFS(vfs, path, fsroot, ...) _vfsMountFS(vfs, path, fsroot, opt_flags(__VA_ARGS__))
 
bool _vfsMountVFS(_Inout_ VFS* vfs, _In_opt_ strref path, _Inout_ VFS* vfs2,
                  _In_opt_ strref vfs2root, flags_t flags);
 
#define vfsMountVFS(vfs, path, vfs2, vfs2root, ...) \
    _vfsMountVFS(vfs, path, vfs2, vfs2root, opt_flags(__VA_ARGS__))
 
void vfsCurDir(_Inout_ VFS* vfs, _Inout_ string* out);
 
bool vfsSetCurDir(_Inout_ VFS* vfs, _In_opt_ strref cur);
 
#define VFS_CACHE_MAXDIRS 4096
#define VFS_CACHE_TTL     timeS(300)
 
void vfsSetCacheLimits(_Inout_ VFS* vfs, uint32 maxdirs, int64 ttl);
 
void vfsPruneCache(_Inout_ VFS* vfs);
 
void vfsAbsolutePath(_Inout_ VFS* vfs, _Inout_ string* out, _In_opt_ strref path);
 
#define _vfsStatAnno _Success_(return != FS_Nonexistent)
 
_vfsStatAnno FSPathStat vfsStat(_Inout_ VFS* vfs, _In_opt_ strref path, _Out_opt_ FSStat* stat);
 
_meta_inline bool vfsExist(_Inout_ VFS* vfs, _In_opt_ strref path)
{
    return vfsStat(vfs, path, NULL) != FS_Nonexistent;
}
 
_meta_inline bool vfsIsDir(_Inout_ VFS* vfs, _In_opt_ strref path)
{
    return vfsStat(vfs, path, NULL) == FS_Directory;
}
 
_meta_inline bool vfsIsFile(_Inout_ VFS* vfs, _In_opt_ strref path)
{
    return vfsStat(vfs, path, NULL) == FS_File;
}
 
bool vfsSetTimes(_Inout_ VFS* vfs, _In_opt_ strref path, int64 modified, int64 accessed);
 
bool vfsCreateDir(_Inout_ VFS* vfs, _In_opt_ strref path);
 
bool vfsCreateAll(_Inout_ VFS* vfs, _In_opt_ strref path);
 
bool vfsRemoveDir(_Inout_ VFS* vfs, _In_opt_ strref path);
 
bool vfsDelete(_Inout_ VFS* vfs, _In_opt_ strref path);
 
bool vfsCopy(_Inout_ VFS* vfs, _In_opt_ strref from, _In_opt_ strref to);
 
bool vfsRename(_Inout_ VFS* vfs, _In_opt_ strref from, _In_opt_ strref to);
 
bool vfsGetFSPath(_Inout_ string* out, _Inout_ VFS* vfs, _In_opt_ strref path);
 
typedef struct FSSearchIter FSSearchIter;
 
bool vfsSearchInit(_Out_ FSSearchIter* iter, _Inout_ VFS* vfs, _In_opt_ strref path,
                   _In_opt_ strref pattern, int typefilter, bool stat);
 
bool vfsSearchNext(_Inout_ FSSearchIter* iter);
 
void vfsSearchFinish(_Inout_ FSSearchIter* iter);
 
_meta_inline bool vfsSearchValid(_In_ FSSearchIter* iter)
{
    return iter->_search;
}
 
_Ret_opt_valid_ VFSFile* vfsOpen(_Inout_ VFS* vfs, _In_opt_ strref path, flags_t flags);
 
_meta_inline bool vfsRead(_Inout_ VFSFile* file, _Out_writes_bytes_to_(sz, *bytesread) void* buf,
                          size_t sz, _Out_ _Deref_out_range_(0, sz) size_t* bytesread)
{
    if (!file) {
        *bytesread = 0;
        return false;
    }
    return fileRead(file, buf, sz, bytesread);
}
 
_meta_inline bool vfsWrite(_Inout_ VFSFile* file, _In_reads_bytes_(sz) const void* buf, size_t sz,
                           _Out_opt_ _Deref_out_range_(0, sz) size_t* byteswritten)
{
    if (!file) {
        if (byteswritten)
            *byteswritten = 0;
        return false;
    }
    return fileWrite(file, buf, sz, byteswritten);
}
 
_meta_inline bool vfsWriteString(_Inout_ VFSFile* file, _In_opt_ strref str,
                                 _Out_opt_ size_t* byteswritten)
{
    if (!file) {
        if (byteswritten)
            *byteswritten = 0;
        return false;
    }
    return fileWriteString(file, str, byteswritten);
}
 
_meta_inline int64 vfsTell(_Inout_ VFSFile* file)
{
    if (!file)
        return -1;
    return fileTell(file);
}
 
_meta_inline int64 vfsSeek(_Inout_ VFSFile* file, int64 off, FSSeekType seektype)
{
    if (!file)
        return -1;
    return fileSeek(file, off, seektype);
}
 
_meta_inline bool vfsFlush(_Inout_ VFSFile* file)
{
    if (!file)
        return false;
    return fileFlush(file);
}
 
enum VFSFlags {
    // Flags valid for both VFS creation and provider mounting:
 
    VFS_ReadOnly = 0x00000001,   
 
    VFS_CaseSensitive = 0x00000002,   
 
    VFS_NoCache = 0x00000004,   
 
    // Flags valid only for provider mounting:
 
    VFS_NewFiles = 0x00000008,   
 
    VFS_AlwaysCOW = 0x00000010,   
 
    VFS_Opaque = 0x00000020,      
};
 
 
CX_C_END