1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
|
// cFile.h
// Interfaces to the cFile class providing an OS-independent abstraction of a file.
/*
The object is optimized towards binary reads.
The object has no multithreading locks, don't use from multiple threads!
Usage:
1, Construct a cFile instance (no-param constructor)
2, Open a file using Open(), check return value for success
3, Read / write
4, Destroy the instance
-- OR --
1, Construct a cFile instance opening the file (filename-param constructor)
2, Check if the file was opened using IsOpen()
3, Read / write
4, Destroy the instance
For reading entire files into memory, just use the static cFile::ReadWholeFile()
*/
#pragma once
// tolua_begin
class cFile
{
public:
// tolua_end
inline static char PathSeparator()
{
#ifdef _WIN32
return '\\';
#else
return '/';
#endif
}
/** The mode in which to open the file */
enum eMode
{
fmRead, // Read-only. If the file doesn't exist, object will not be valid
fmWrite, // Write-only. If the file already exists, it will be overwritten
fmReadWrite, // Read / write. If the file already exists, it will be left intact; writing will overwrite the data from the beginning
fmAppend // Write-only. If the file already exists cursor will be moved to the end of the file
} ;
/** Simple constructor - creates an unopened file object, use Open() to open / create a real file */
cFile(void);
/** Constructs and opens / creates the file specified, use IsOpen() to check for success */
cFile(const AString & iFileName, eMode iMode);
/** Auto-closes the file, if open */
~cFile();
bool Open(const AString & iFileName, eMode iMode);
void Close(void);
bool IsOpen(void) const;
bool IsEOF(void) const;
/** Reads up to a_NumBytes bytes into a_Buffer, returns the number of bytes actually read, or -1 on failure; asserts if not open */
int Read(void * a_Buffer, size_t a_NumBytes);
/** Reads up to a_NumBytes bytes, returns the bytes actually read, or empty string on failure; asserts if not open */
AString Read(size_t a_NumBytes);
/** Writes up to a_NumBytes bytes from a_Buffer, returns the number of bytes actually written, or -1 on failure; asserts if not open */
int Write(const void * a_Buffer, size_t a_NumBytes);
int Write(std::string_view a_String)
{
return Write(a_String.data(), a_String.size());
}
/** Seeks to iPosition bytes from file start, returns old position or -1 for failure; asserts if not open */
long Seek (int iPosition);
/** Returns the current position (bytes from file start) or -1 for failure; asserts if not open */
long Tell (void) const;
/** Returns the size of file, in bytes, or -1 for failure; asserts if not open */
long GetSize(void) const;
/** Reads the file from current position till EOF into an AString; returns the number of bytes read or -1 for error */
int ReadRestOfFile(AString & a_Contents);
/** Returns true if the file specified exists */
static bool Exists(const AString & a_FileName); // Exported in ManualBindings.cpp
/** Deletes a file or a folder, returns true if successful.
Prefer to use DeleteFile or DeleteFolder, since those don't have the penalty of checking whether a_Path is a folder. */
static bool Delete(const AString & a_Path); // Exported in ManualBindings.cpp
/** Deletes a file, returns true if successful.
Returns false if a_FileName points to a folder. */
static bool DeleteFile(const AString & a_FileName); // Exported in ManualBindings.cpp
/** Deletes a folder, returns true if successful.
Returns false if a_FolderName points to a file. */
static bool DeleteFolder(const AString & a_FolderName); // Exported in ManualBindings.cpp
/** Deletes all content from the specified folder.
The specified folder itself stays intact.
Returns true on success, false on failure. */
static bool DeleteFolderContents(const AString & a_FolderName); // Exported in ManualBindings.cpp
/** Renames a file or folder, returns true if successful. May fail if dest already exists (libc-dependant)! */
static bool Rename(const AString & a_OrigPath, const AString & a_NewPath); // Exported in ManualBindings.cpp
/** Copies a file, returns true if successful.
Overwrites the dest file if it already exists. */
static bool Copy(const AString & a_SrcFileName, const AString & a_DstFileName); // Exported in ManualBindings.cpp
/** Returns true if the specified path is a folder */
static bool IsFolder(const AString & a_Path); // Exported in ManualBindings.cpp
/** Returns true if the specified path is a regular file */
static bool IsFile(const AString & a_Path); // Exported in ManualBindings.cpp
/** Returns the size of the file, or a negative number on error */
static long GetSize(const AString & a_FileName); // Exported in ManualBindings.cpp
/** Creates a new folder with the specified name. Returns true if successful. Path may be relative or absolute */
static bool CreateFolder(const AString & a_FolderPath); // Exported in ManualBindings.cpp
/** Creates a new folder with the specified name, creating its parents if needed. Path may be relative or absolute.
Returns true if the folder exists at the end of the operation (either created, or already existed).
Supports only paths that use the path separator used by the current platform (MSVC CRT supports slashes for file paths, too, but this function doesn't) */
static bool CreateFolderRecursive(const AString & a_FolderPath); // Exported in ManualBindings.cpp
/** Returns the entire contents of the specified file as a string. Returns empty string on error. */
static AString ReadWholeFile(const AString & a_FileName); // Exported in ManualBindings.cpp
/** Returns a_FileName with its extension changed to a_NewExt.
a_FileName may contain path specification. */
static AString ChangeFileExt(const AString & a_FileName, const AString & a_NewExt); // Exported in ManualBindings.cpp
/** Returns the last modification time (in current timezone) of the specified file.
The value returned is in the same units as the value returned by time() function.
If the file is not found / accessible, zero is returned.
Works for folders, too, when specified without the trailing path separator. */
static unsigned GetLastModificationTime(const AString & a_FileName); // Exported in ManualBindings.cpp
// tolua_begin
/** Returns the path separator used by the current platform.
Note that the platform / CRT may support additional path separators (such as slashes on Windows), these don't get reported. */
static AString GetPathSeparator(void);
/** Returns the customary executable extension used by the current platform. */
static AString GetExecutableExt(void);
// tolua_end
/** Returns the list of all items in the specified folder (files, folders, nix pipes, whatever's there). */
static AStringVector GetFolderContents(const AString & a_Folder); // Exported in ManualBindings.cpp
int vPrintf(const char * a_Format, fmt::printf_args a_ArgList);
template <typename... Args>
int Printf(const char * a_Format, const Args & ... a_Args)
{
return vPrintf(a_Format, fmt::make_printf_args(a_Args...));
}
/** Flushes all the bufferef output into the file (only when writing) */
void Flush(void);
private:
FILE * m_File;
} ; // tolua_export
/** A wrapper for file streams that enables exceptions. */
template <class StreamType>
class FileStream final : public StreamType
{
public:
FileStream(const std::string & Path);
};
using InputFileStream = FileStream<std::ifstream>;
using OutputFileStream = FileStream<std::ofstream>;
|
