Subversion Repositories spk

Rev

Rev 4 | Details | Compare with Previous | Last modification | View Log | RSS feed

Rev Author Line No. Line
4 cycrow 1 
 
2 
#include <malloc.h>
3 
#include "clsFile.h"
4 
 
5 
clsFILE::clsFILE()
6 
{
7 
	InitVars();
8 
}
9 
 
10 
clsFILE::~clsFILE()
11 
{
12 
	// Cleanup
13 
	Destroy();
14 
}
15 
 
16 
 
17 
//
18 
// Open a file in the specified mode
19 
//
20 
BOOL clsFILE::GetFileHandle(char *szFilePath, DWORD dwMode)
21 
{
22 
	DWORD  dwFlags, dwAccess, dwShare;
23 
 
24 
	// destroy if sth is already loaded
25 
	Destroy();
26 
 
27 
	// save path
7 cycrow 28 
	strcpy(cFilePath, szFilePath);
4 cycrow 29 
 
30 
	// handle flags
31 
	switch(dwMode)
32 
	{
33 
	case F_OPENEXISTING_R:
34 
		bReadOnly = TRUE;
35 
		dwFlags = OPEN_EXISTING;
36 
		dwAccess = GENERIC_READ;
37 
		dwShare = FILE_SHARE_READ;
38 
		break;
39 
 
40 
	case F_OPENEXISTING_RW:
41 
		bReadOnly = FALSE;
42 
		dwFlags = OPEN_EXISTING;
43 
		dwAccess = GENERIC_READ | GENERIC_WRITE;
44 
		dwShare = FILE_SHARE_READ | FILE_SHARE_WRITE;
45 
		break;
46 
 
47 
	case F_CREATENEW:
48 
		bReadOnly = FALSE;
49 
		dwFlags = CREATE_ALWAYS;
50 
		dwAccess = GENERIC_READ | GENERIC_WRITE;
51 
		dwShare = FILE_SHARE_READ | FILE_SHARE_WRITE;
52 
		break;
53 
 
54 
	case F_TRUNCATE: // RW
55 
		bReadOnly = FALSE;
56 
		dwFlags = TRUNCATE_EXISTING;
57 
		dwAccess = GENERIC_READ | GENERIC_WRITE;
58 
		dwShare = FILE_SHARE_READ | FILE_SHARE_WRITE;
59 
		break;
60 
	}
61 
 
7 cycrow 62 
	TCHAR tempFilePath[MAX_PATH];
63 
	MultiByteToWideChar(CP_UTF8,0,szFilePath,-1,tempFilePath,MAX_PATH);
64 
 
4 cycrow 65 
	hFile = CreateFile(
7 cycrow 66 
		tempFilePath,
4 cycrow 67 
		dwAccess,
68 
		dwShare,
69 
		NULL,
70 
		dwFlags,
71 
		FILE_ATTRIBUTE_NORMAL,
72 
		NULL);
73 
	if (hFile == (HANDLE)-1)
74 
		return FALSE;
75 
 
76 
	return TRUE;
77 
}
78 
 
79 
//
80 
// opens a file with RW access if possible else just R
81 
BOOL clsFILE::GetFileHandleWithMaxAccess(char* szFilePath)
82 
{
83 
	BOOL bRet;
84 
 
85 
	bRet = GetFileHandle(szFilePath, F_OPENEXISTING_RW);
86 
	if (!bRet)
87 
		bRet = GetFileHandle(szFilePath, F_OPENEXISTING_R);
88 
 
89 
	return bRet;
90 
}
91 
 
92 
//
93 
// Cleanup routine
94 
//
95 
BOOL clsFILE::Destroy()
96 
{
97 
	BOOL bRet = FALSE;
98 
 
99 
	// cleanup
100 
	if (hFile != INVALID_HANDLE_VALUE)
101 
		if (CloseHandle(hFile))
102 
			bRet = TRUE;
103 
	if (pMap)
104 
		free(pMap);
105 
 
106 
	// adjust vars
107 
	InitVars();
108 
 
109 
	return bRet;
110 
}
111 
 
112 
void clsFILE::InitVars()
113 
{
114 
	hFile        = INVALID_HANDLE_VALUE;
115 
	pMap         = NULL;
116 
	dwMapSize    = 0;
117 
 
118 
	return;
119 
}
120 
 
121 
//
122 
// returns:
123 
// INVALID_HANDLE_VALUE - if no file is loaded
124 
//
125 
HANDLE clsFILE::GetHandle()
126 
{
127 
	return hFile;
128 
}
129 
 
130 
BOOL clsFILE::IsFileReadOnly()
131 
{
132 
	return bReadOnly;
133 
}
134 
 
135 
BOOL clsFILE::MapFile()
136 
{
137 
	DWORD dw, dwFSize;
138 
 
139 
	if (hFile == INVALID_HANDLE_VALUE)
140 
		return FALSE;
141 
 
142 
	dwFSize = GetFSize();
143 
 
144 
	// map file
145 
	pMap = malloc( dwFSize );
146 
	if (!pMap)
147 
		return FALSE;
148 
	if (!ReadFile(hFile, pMap, dwFSize, &dw, NULL))
149 
		return FALSE;
150 
 
151 
	// set vars
152 
	dwMapSize = dwFSize;
153 
 
154 
	return TRUE;
155 
}
156 
 
157 
void* clsFILE::GetMapPtr()
158 
{
159 
	return pMap;
160 
}
161 
 
162 
BOOL clsFILE::UnmapFile()
163 
{
164 
	if (!pMap)
165 
		return FALSE;
166 
 
167 
	free(pMap);
168 
	pMap       = NULL;
169 
	dwMapSize  = 0;
170 
 
171 
	return TRUE;
172 
}
173 
 
174 
//
175 
// change size of file memory
176 
//
177 
BOOL clsFILE::ReMapFile(DWORD dwNewSize)
178 
{
179 
	if (!pMap)
180 
		return FALSE; // ERR
181 
 
182 
	pMap = realloc(pMap, dwNewSize);
183 
	if (pMap)
184 
	{
185 
		pMap      = NULL;
186 
		dwMapSize = dwNewSize;
187 
		return TRUE; // OK
188 
	}
189 
	else
190 
		return FALSE; // ERR
191 
}
192 
 
193 
//
194 
// returns:
195 
// -1 in the case of an error
196 
//
197 
DWORD clsFILE::GetMapSize()
198 
{
199 
	if (!pMap)
200 
		return (DWORD)-1; // ERR
201 
 
202 
	return dwMapSize;
203 
}
204 
 
205 
BOOL clsFILE::IsMapped()
206 
{
207 
	return pMap != NULL ? TRUE : FALSE;
208 
}
209 
 
210 
//
211 
// copy mapping memory to file
212 
//
213 
BOOL clsFILE::FlushFileMap()
214 
{
215 
	if ( !Truncate() )
216 
		return FALSE; // ERR
217 
 
218 
	return Write(pMap, dwMapSize);
219 
}
220 
 
221 
BOOL clsFILE::FileExists(char* szFilePath)
222 
{
223 
	clsFILE   *f = new clsFILE;
224 
	BOOL      b;
225 
 
226 
	b = f->GetFileHandle(szFilePath, F_OPENEXISTING_R);
227 
	if ( b )
228 
		f->Destroy();
229 
 
230 
	return b;
231 
}
232 
 
233 
DWORD clsFILE::GetFSize()
234 
{
235 
	return GetFileSize(hFile, NULL);
236 
}
237 
 
238 
//
239 
// returns:
240 
// NULL - if no file is loaded
241 
//
242 
char* clsFILE::GetFilePath()
243 
{
244 
	if (hFile == (HANDLE)-1)
245 
		return NULL;
246 
 
247 
	return cFilePath;
248 
}
249 
 
250 
//
251 
// write to file
252 
//
253 
BOOL clsFILE::Write(void* pBuff, DWORD dwc)
254 
{
255 
	DWORD  dwRet;
256 
	BOOL   bRet;
257 
 
258 
	bRet = WriteFile(hFile, pBuff, dwc, &dwRet, NULL);
259 
 
260 
	return (bRet && dwc == dwRet) ? TRUE : FALSE;
261 
}
262 
 
263 
//
264 
// read from file
265 
//
266 
BOOL clsFILE::Read(void* pBuff, DWORD dwc)
267 
{
268 
	DWORD  dwRet;
269 
	BOOL   bRet;
270 
 
271 
	bRet = ReadFile(hFile, pBuff, dwc, &dwRet, NULL);
272 
 
273 
	return (bRet && dwc == dwRet) ? TRUE : FALSE;
274 
}
275 
 
276 
//
277 
// set file pointer
278 
//
279 
BOOL clsFILE::SetFPointer(DWORD dwOff)
280 
{
281 
	DWORD dwRet;
282 
 
283 
	dwRet = SetFilePointer(hFile, dwOff, NULL, FILE_BEGIN);
284 
 
285 
	return (dwRet != (DWORD)-1) ? TRUE : FALSE;
286 
}
287 
 
288 
BOOL clsFILE::Truncate()
289 
{
290 
	if (!SetFPointer(0))
291 
		return FALSE; // ERR
292 
	if (!SetEndOfFile(hFile))
293 
		return FALSE; // ERR
294 
 
295 
	return TRUE; // OK
296 
}
297 
 
298 
void clsFILE::SetMapPtrSize(void* ptr, DWORD dwSize)
299 
{
300 
	pMap      = ptr;
301 
	dwMapSize = dwSize;
302 
 
303 
	return;
304 
}