vfsfile.h

Go to the documentation of this file.

 
 
#pragma once
// This header file is auto-generated!
// Do not make changes to this file or they will be overwritten.
// clang-format off
#include <cx/obj.h>
#include <cx/struct.h>
#include <cx/fs/fileobj.h>
#include <cx/fs/vfsobj.h>
 
CX_C_BEGIN
 
typedef struct VFSDir VFSDir;
typedef struct VFSFile VFSFile;
typedef struct VFSFile_WeakRef VFSFile_WeakRef;
saDeclarePtr(VFSFile);
saDeclarePtr(VFSFile_WeakRef);
#define _sti_VFSFile _sti_object
#define SType_VFSFile VFSFile*
#define STStorageType_VFSFile VFSFile*
#define STypeArg_VFSFile(type, val) stgeneric(object, (ObjInst*)objInstCheckClass(VFSFile, val))
#define STypeArgPtr_VFSFile(type, val) (stgeneric*)objInstCheckClassPtr(VFSFile, val)
#define STypeCheckedArg_VFSFile(type, val)    stType(type), stArg(type, val)
#define STypeCheckedPtrArg_VFSFile(type, val) stType(type), stArgPtr(type, val)
 
 
 
typedef struct VFSFile_ClassIf {
    ObjIface* _implements;
    ObjIface* _parent;
    size_t _size;
 
    // Flushes pending writes and closes the underlying handle without releasing the File.
    // Implemented by each kind of File; callers use fileClose() instead. Further reads and
    // writes fail, and closing an already closed file must be harmless. Returns true if
    // successful, false if flushing or closing failed or if self was NULL.
    bool (*closeHandle)(_In_ void* self);
    bool (*read)(_In_ void* self, _Out_writes_bytes_to_(sz, *bytesread) void* buf, size_t sz, _Out_ _Deref_out_range_(0, sz) size_t* bytesread);
    bool (*write)(_In_ void* self, _In_reads_bytes_(sz) const void* buf, size_t sz, _Out_opt_ _Deref_out_range_(0, sz) size_t* byteswritten);
    int64 (*tell)(_In_ void* self);
    int64 (*seek)(_In_ void* self, int64 off, FSSeekType seektype);
    bool (*flush)(_In_ void* self);
} VFSFile_ClassIf;
extern VFSFile_ClassIf VFSFile_ClassIf_tmpl;
 
typedef struct VFSFile {
    union {
        VFSFile_ClassIf* _;
        void* _is_VFSFile;
        void* _is_File;
        void* _is_ObjInst;
    };
    ObjClassInfo* _clsinfo;
    atomic(uintptr) _ref;
    atomic(ptr) _weakref;
 
    VFS* vfs;
    File* inner;        // the provider's file, which every operation ends up at
    // for copy-on-write files
    // VFSProvider
    ObjInst* cowprov;
    string cowpath;        // absolute path to COW file (for cache invalidation)
    string cowrpath;        // relative path for COW file for provider
} VFSFile;
extern ObjClassInfo VFSFile_clsinfo;
#define VFSFile(inst) objInstCheckClass(VFSFile, inst)
#define VFSFileNone ((VFSFile*)NULL)
 
typedef struct VFSFile_WeakRef {
    union {
        ObjInst* _inst;
        void* _is_VFSFile_WeakRef;
        void* _is_File_WeakRef;
        void* _is_ObjInst_WeakRef;
    };
    atomic(uintptr) _ref;
    RWLock _lock;
} VFSFile_WeakRef;
#define VFSFile_WeakRef(inst) objWeakRefCheckClass(VFSFile, inst)
 
_objfactory_guaranteed VFSFile* VFSFile_create(VFS* vfs, File* inner);
// VFSFile* vfsfileCreate(VFS* vfs, File* inner);
#define vfsfileCreate(vfs, inner) VFSFile_create(VFS(vfs), File(inner))
 
#define vfsfileWriteString(self, str, byteswritten) File_writeString(File(self), str, byteswritten)
 
// bool vfsfileCloseHandle(VFSFile* self);
//
// Flushes pending writes and closes the underlying handle without releasing the File.
// Implemented by each kind of File; callers use fileClose() instead. Further reads and
// writes fail, and closing an already closed file must be harmless. Returns true if
// successful, false if flushing or closing failed or if self was NULL.
#define vfsfileCloseHandle(self) ((self) ? ((self)->_->closeHandle(VFSFile(self))) : false)
// bool vfsfileRead(VFSFile* self, void* buf, size_t sz, size_t* bytesread);
#define vfsfileRead(self, buf, sz, bytesread) ((self) ? ((self)->_->read(VFSFile(self), buf, sz, bytesread)) : false)
// bool vfsfileWrite(VFSFile* self, const void* buf, size_t sz, size_t* byteswritten);
#define vfsfileWrite(self, buf, sz, byteswritten) ((self) ? ((self)->_->write(VFSFile(self), buf, sz, byteswritten)) : false)
// int64 vfsfileTell(VFSFile* self);
#define vfsfileTell(self) ((self) ? ((self)->_->tell(VFSFile(self))) : -1)
// int64 vfsfileSeek(VFSFile* self, int64 off, FSSeekType seektype);
#define vfsfileSeek(self, off, seektype) ((self) ? ((self)->_->seek(VFSFile(self), off, seektype)) : -1)
// bool vfsfileFlush(VFSFile* self);
#define vfsfileFlush(self) ((self) ? ((self)->_->flush(VFSFile(self))) : false)
 
CX_C_END