Subversion Repositories spk

Rev

Go to most recent revision | Details | 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
28 
	lstrcpy(cFilePath, szFilePath);
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 
 
62 
	hFile = CreateFile(
63 
		szFilePath,
64 
		dwAccess,
65 
		dwShare,
66 
		NULL,
67 
		dwFlags,
68 
		FILE_ATTRIBUTE_NORMAL,
69 
		NULL);
70 
	if (hFile == (HANDLE)-1)
71 
		return FALSE;
72 
 
73 
	return TRUE;
74 
}
75 
 
76 
//
77 
// opens a file with RW access if possible else just R
78 
BOOL clsFILE::GetFileHandleWithMaxAccess(char* szFilePath)
79 
{
80 
	BOOL bRet;
81 
 
82 
	bRet = GetFileHandle(szFilePath, F_OPENEXISTING_RW);
83 
	if (!bRet)
84 
		bRet = GetFileHandle(szFilePath, F_OPENEXISTING_R);
85 
 
86 
	return bRet;
87 
}
88 
 
89 
//
90 
// Cleanup routine
91 
//
92 
BOOL clsFILE::Destroy()
93 
{
94 
	BOOL bRet = FALSE;
95 
 
96 
	// cleanup
97 
	if (hFile != INVALID_HANDLE_VALUE)
98 
		if (CloseHandle(hFile))
99 
			bRet = TRUE;
100 
	if (pMap)
101 
		free(pMap);
102 
 
103 
	// adjust vars
104 
	InitVars();
105 
 
106 
	return bRet;
107 
}
108 
 
109 
void clsFILE::InitVars()
110 
{
111 
	hFile        = INVALID_HANDLE_VALUE;
112 
	pMap         = NULL;
113 
	dwMapSize    = 0;
114 
 
115 
	return;
116 
}
117 
 
118 
//
119 
// returns:
120 
// INVALID_HANDLE_VALUE - if no file is loaded
121 
//
122 
HANDLE clsFILE::GetHandle()
123 
{
124 
	return hFile;
125 
}
126 
 
127 
BOOL clsFILE::IsFileReadOnly()
128 
{
129 
	return bReadOnly;
130 
}
131 
 
132 
BOOL clsFILE::MapFile()
133 
{
134 
	DWORD dw, dwFSize;
135 
 
136 
	if (hFile == INVALID_HANDLE_VALUE)
137 
		return FALSE;
138 
 
139 
	dwFSize = GetFSize();
140 
 
141 
	// map file
142 
	pMap = malloc( dwFSize );
143 
	if (!pMap)
144 
		return FALSE;
145 
	if (!ReadFile(hFile, pMap, dwFSize, &dw, NULL))
146 
		return FALSE;
147 
 
148 
	// set vars
149 
	dwMapSize = dwFSize;
150 
 
151 
	return TRUE;
152 
}
153 
 
154 
void* clsFILE::GetMapPtr()
155 
{
156 
	return pMap;
157 
}
158 
 
159 
BOOL clsFILE::UnmapFile()
160 
{
161 
	if (!pMap)
162 
		return FALSE;
163 
 
164 
	free(pMap);
165 
	pMap       = NULL;
166 
	dwMapSize  = 0;
167 
 
168 
	return TRUE;
169 
}
170 
 
171 
//
172 
// change size of file memory
173 
//
174 
BOOL clsFILE::ReMapFile(DWORD dwNewSize)
175 
{
176 
	if (!pMap)
177 
		return FALSE; // ERR
178 
 
179 
	pMap = realloc(pMap, dwNewSize);
180 
	if (pMap)
181 
	{
182 
		pMap      = NULL;
183 
		dwMapSize = dwNewSize;
184 
		return TRUE; // OK
185 
	}
186 
	else
187 
		return FALSE; // ERR
188 
}
189 
 
190 
//
191 
// returns:
192 
// -1 in the case of an error
193 
//
194 
DWORD clsFILE::GetMapSize()
195 
{
196 
	if (!pMap)
197 
		return (DWORD)-1; // ERR
198 
 
199 
	return dwMapSize;
200 
}
201 
 
202 
BOOL clsFILE::IsMapped()
203 
{
204 
	return pMap != NULL ? TRUE : FALSE;
205 
}
206 
 
207 
//
208 
// copy mapping memory to file
209 
//
210 
BOOL clsFILE::FlushFileMap()
211 
{
212 
	if ( !Truncate() )
213 
		return FALSE; // ERR
214 
 
215 
	return Write(pMap, dwMapSize);
216 
}
217 
 
218 
BOOL clsFILE::FileExists(char* szFilePath)
219 
{
220 
	clsFILE   *f = new clsFILE;
221 
	BOOL      b;
222 
 
223 
	b = f->GetFileHandle(szFilePath, F_OPENEXISTING_R);
224 
	if ( b )
225 
		f->Destroy();
226 
 
227 
	return b;
228 
}
229 
 
230 
DWORD clsFILE::GetFSize()
231 
{
232 
	return GetFileSize(hFile, NULL);
233 
}
234 
 
235 
//
236 
// returns:
237 
// NULL - if no file is loaded
238 
//
239 
char* clsFILE::GetFilePath()
240 
{
241 
	if (hFile == (HANDLE)-1)
242 
		return NULL;
243 
 
244 
	return cFilePath;
245 
}
246 
 
247 
//
248 
// write to file
249 
//
250 
BOOL clsFILE::Write(void* pBuff, DWORD dwc)
251 
{
252 
	DWORD  dwRet;
253 
	BOOL   bRet;
254 
 
255 
	bRet = WriteFile(hFile, pBuff, dwc, &dwRet, NULL);
256 
 
257 
	return (bRet && dwc == dwRet) ? TRUE : FALSE;
258 
}
259 
 
260 
//
261 
// read from file
262 
//
263 
BOOL clsFILE::Read(void* pBuff, DWORD dwc)
264 
{
265 
	DWORD  dwRet;
266 
	BOOL   bRet;
267 
 
268 
	bRet = ReadFile(hFile, pBuff, dwc, &dwRet, NULL);
269 
 
270 
	return (bRet && dwc == dwRet) ? TRUE : FALSE;
271 
}
272 
 
273 
//
274 
// set file pointer
275 
//
276 
BOOL clsFILE::SetFPointer(DWORD dwOff)
277 
{
278 
	DWORD dwRet;
279 
 
280 
	dwRet = SetFilePointer(hFile, dwOff, NULL, FILE_BEGIN);
281 
 
282 
	return (dwRet != (DWORD)-1) ? TRUE : FALSE;
283 
}
284 
 
285 
BOOL clsFILE::Truncate()
286 
{
287 
	if (!SetFPointer(0))
288 
		return FALSE; // ERR
289 
	if (!SetEndOfFile(hFile))
290 
		return FALSE; // ERR
291 
 
292 
	return TRUE; // OK
293 
}
294 
 
295 
void clsFILE::SetMapPtrSize(void* ptr, DWORD dwSize)
296 
{
297 
	pMap      = ptr;
298 
	dwMapSize = dwSize;
299 
 
300 
	return;
301 
}