fileobj.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/fs.h>
 
CX_C_BEGIN
 
typedef struct File File;
typedef struct File_WeakRef File_WeakRef;
saDeclarePtr(File);
saDeclarePtr(File_WeakRef);
#define _sti_File _sti_object
#define SType_File File*
#define STStorageType_File File*
#define STypeArg_File(type, val) stgeneric(object, (ObjInst*)objInstCheckClass(File, val))
#define STypeArgPtr_File(type, val) (stgeneric*)objInstCheckClassPtr(File, val)
#define STypeCheckedArg_File(type, val)    stType(type), stArg(type, val)
#define STypeCheckedPtrArg_File(type, val) stType(type), stArgPtr(type, val)
 
 
 
typedef struct File_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);
} File_ClassIf;
extern File_ClassIf File_ClassIf_tmpl;
 
typedef struct File {
    union {
        File_ClassIf* _;
        void* _is_File;
        void* _is_ObjInst;
    };
    ObjClassInfo* _clsinfo;
    atomic(uintptr) _ref;
    atomic(ptr) _weakref;
 
} File;
extern ObjClassInfo File_clsinfo;
#define File(inst) objInstCheckClass(File, inst)
#define FileNone ((File*)NULL)
 
typedef struct File_WeakRef {
    union {
        ObjInst* _inst;
        void* _is_File_WeakRef;
        void* _is_ObjInst_WeakRef;
    };
    atomic(uintptr) _ref;
    RWLock _lock;
} File_WeakRef;
#define File_WeakRef(inst) objWeakRefCheckClass(File, inst)
 
bool File_writeString(_In_ File* self, _In_opt_ strref str, _Out_opt_ size_t* byteswritten);
#define fileWriteString(self, str, byteswritten) File_writeString(File(self), str, byteswritten)
 
// bool fileCloseHandle(File* 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 fileCloseHandle(self) ((self) ? ((self)->_->closeHandle(File(self))) : false)
#define fileRead(self, buf, sz, bytesread) ((self) ? ((self)->_->read(File(self), buf, sz, bytesread)) : false)
#define fileWrite(self, buf, sz, byteswritten) ((self) ? ((self)->_->write(File(self), buf, sz, byteswritten)) : false)
#define fileTell(self) ((self) ? ((self)->_->tell(File(self))) : -1)
#define fileSeek(self, off, seektype) ((self) ? ((self)->_->seek(File(self), off, seektype)) : -1)
#define fileFlush(self) ((self) ? ((self)->_->flush(File(self))) : false)
 
CX_C_END