Subversion Repositories spk

Rev

Rev 129 | Rev 183 | Go to most recent revision | Details | Compare with Previous | Last modification | View Log | RSS feed

Rev Author Line No. Line
1 cycrow 1 
#include "DirIO.h"
2 
 
3 
#include <sys/types.h>  // For stat().
4 
#include <sys/stat.h>   // For stat().
5 
#include <fcntl.h>
6 
#include "File.h"
7 
#include "File_IO.h"
8 
 
9 
#ifdef _WIN32
10 
#include <windows.h>
11 
#include <io.h>
12 
#include <direct.h>
13 
#define ACCESS _access
14 
#else
121 cycrow 15 
#include <dirent.h>
1 cycrow 16 
#define ACCESS access
17 
#endif
18 
 
125 cycrow 19 
/////////////////////////////////////////
20 
// STATIC FUNCTIONS
21 
bool CDirIO::Exists(const Utils::String &dir)
22 
{
23 
	return CDirIO(dir).exists();
24 
}
25 
 
26 
 
27 
////////////////////////////////////////
28 
// Ctor/Dtor
29 
 
1 cycrow 30 
CDirIO::CDirIO()
31 
{
32 
}
33 
 
34 
CDirIO::~CDirIO()
35 
{
36 
}
37 
 
38 
CDirIO::CDirIO(CyString dir)
39 
{
160 cycrow 40 
	setDir(dir.ToString());
1 cycrow 41 
}
42 
 
43 
CDirIO::CDirIO ( CFileIO *file )
44 
{
160 cycrow 45 
	setDir(file->dir());
1 cycrow 46 
}
47 
 
125 cycrow 48 
/////////////////////////////////////////////////////////
49 
//
1 cycrow 50 
 
160 cycrow 51 
void CDirIO::setDir(const Utils::String& dir)
1 cycrow 52 
{
160 cycrow 53 
	m_sCurrentDir = dir;
85 cycrow 54 
	m_sCurrentDir.toFilename();
1 cycrow 55 
}
56 
 
121 cycrow 57 
bool CDirIO::exists() const
58 
{
59 
	Utils::String dir = m_sCurrentDir;
60 
 
61 
	if (dir.empty())
62 
		return false;
63 
 
64 
	if (ACCESS(dir.c_str(), 0) == 0)
65 
		return true;
66 
 
67 
	return false;
68 
}
69 
 
70 
bool CDirIO::exists(const Utils::String &dir) const
71 
{
125 cycrow 72 
	Utils::String d = _parseDir(dir);
121 cycrow 73 
 
74 
	if (d.empty())
75 
		return false;
76 
 
77 
	if (ACCESS(d.c_str(), 0) == 0)
78 
		return true;
79 
 
80 
	return false;
81 
}
82 
 
125 cycrow 83 
Utils::String CDirIO::_parseDir(const Utils::String &dir) const
1 cycrow 84 
{
85 cycrow 85 
	Utils::String sDir = dir.asFilename();
86 
	if ( !m_sCurrentDir.empty() && !sDir.isin(":") )
87 
	{
88 
		if ( sDir.empty() )
89 
			sDir = m_sCurrentDir;
90 
		else
91 
			sDir = m_sCurrentDir + "/" + sDir;
92 
	}
93 
 
94 
	return sDir.asFilename();
95 
}
96 
 
121 cycrow 97 
bool CDirIO::isDir(const Utils::String &sDir) const
98 
{
125 cycrow 99 
	Utils::String dir = _parseDir(sDir);
121 cycrow 100 
	if (ACCESS(dir.c_str(), 0) != -1)
101 
	{
102 
		struct stat status;
103 
		stat(dir.c_str(), &status);
104 
 
105 
		if (status.st_mode & S_IFDIR)
106 
			return true;
107 
	}
108 
	else {
109 
		return !dir.token("/", -1).isin(".");
110 
	}
111 
 
112 
	return false;
113 
}
114 
 
115 
bool CDirIO::isDir() const
116 
{
117 
	return isDir(m_sCurrentDir);
118 
}
119 
 
120 
bool CDirIO::isFile() const
121 
{
122 
	return isFile(m_sCurrentDir);
123 
}
124 
bool CDirIO::isFile(const Utils::String &sDir) const
125 
{
125 cycrow 126 
	Utils::String dir = _parseDir(sDir);
121 cycrow 127 
	if (ACCESS(dir.c_str(), 0) != -1)
128 
	{
129 
		struct stat status;
130 
		stat(dir.c_str(), &status);
131 
 
132 
		if (status.st_mode & S_IFDIR)
133 
			return false;
134 
		else
135 
			return true;
136 
	}
137 
	else {
138 
		return dir.token("/", -1).isin(".");
139 
	}
140 
 
141 
	return false;
142 
}
1 cycrow 143 
 
160 cycrow 144 
 
129 cycrow 145 
bool CDirIO::create() const
146 
{
147 
	return create(Utils::String::Null());
148 
}
149 
bool CDirIO::create(const Utils::String &sDir) const
150 
{
151 
	Utils::String dir = sDir;
121 cycrow 152 
	if ( dir.empty() )
1 cycrow 153 
		dir = m_sCurrentDir;
125 cycrow 154 
	dir = _parseDir(dir);
1 cycrow 155 
 
156 
	// split up directorys
157 
	int max = 0;
121 cycrow 158 
	Utils::String *dirs = dir.findReplace( "/", "\\" ).findReplace( "\\\\", "\\" ).tokenise("\\", &max );
1 cycrow 159 
 
160 
	// check if full dir, or relative
161 
	int start = 1;
121 cycrow 162 
	Utils::String curDir;
1 cycrow 163 
 
164 
	if ( dirs && max )
165 
		curDir = dirs[0];
166 
 
121 cycrow 167 
	if ( !curDir.isin(":") )
1 cycrow 168 
	{
169 
		curDir = m_sCurrentDir;
170 
		start = 0;
171 
	}
172 
 
173 
	// process each dir
174 
	for ( int i = start; i < max; i++ )
175 
	{
121 cycrow 176 
		if ( !curDir.empty() )
1 cycrow 177 
			curDir += "/";
178 
		curDir += dirs[i];
179 
 
180 
		// check if the directory exists
121 cycrow 181 
		if ( !exists(curDir) )
1 cycrow 182 
		{
183 
#ifdef _WIN32
184 
			if ( _mkdir(curDir.c_str()) )
185 
#else
186 
			if ( mkdir(curDir.c_str(), 0755) )
187 
#endif
188 
			{
189 
				CLEANSPLIT(dirs, max);
190 
				return false;
191 
			}
192 
		}
193 
	}
194 
 
195 
	CLEANSPLIT(dirs, max);
196 
 
197 
	return true;
198 
}
199 
 
125 cycrow 200 
bool CDirIO::move(const Utils::String &sTo)
1 cycrow 201 
{
125 cycrow 202 
	Utils::String to = _parseDir(sTo);
1 cycrow 203 
 
125 cycrow 204 
	if (exists(to))
205 
		return false;
206 
 
207 
	if (!rename(m_sCurrentDir.c_str(), to.c_str()))
1 cycrow 208 
	{
125 cycrow 209 
		m_sCurrentDir = to;
210 
		return true;
211 
	}
212 
 
213 
	return false;
214 
}
215 
 
216 
 
160 cycrow 217 
bool CDirIO::move(const Utils::String &sFrom, const Utils::String &sTo)
125 cycrow 218 
{
160 cycrow 219 
	Utils::String from = _parseDir(sFrom);
220 
	Utils::String to = _parseDir(sTo);
125 cycrow 221 
 
222 
	if ( !exists(to) )
223 
	{
160 cycrow 224 
		if ( !create(to) )
1 cycrow 225 
			return false;
226 
	}
227 
 
228 
	if ( !rename(from.c_str(), to.c_str()) )
229 
		return true;
230 
 
231 
	return false;
232 
}
233 
 
160 cycrow 234 
bool CDirIO::checkEmptyDir(const Utils::CStringList &dirList) const
1 cycrow 235 
{
236 
	// not found any files, most likly empty
160 cycrow 237 
	if (dirList.empty())
1 cycrow 238 
		return true;
239 
	// check for any valid files
240 
 
160 cycrow 241 
	for(auto itr = dirList.begin(); itr != dirList.end(); itr++)
1 cycrow 242 
	{
160 cycrow 243 
		Utils::String d = (*itr)->str;
244 
		if (d == "." || d == "..")
1 cycrow 245 
			continue;
246 
 
247 
		// found something
248 
		return false;
249 
	}
250 
 
251 
	return true;
252 
}
253 
 
160 cycrow 254 
bool CDirIO::removeDir(const Utils::String& dir, bool doFiles, bool recursive, Utils::CStringList* errors)
1 cycrow 255 
{
256 
	// check if the dir is empty
160 cycrow 257 
	Utils::CStringList list;
258 
	if (dirList(list, dir))
1 cycrow 259 
	{
160 cycrow 260 
		if (checkEmptyDir(list))
1 cycrow 261 
		{
160 cycrow 262 
			Utils::String remDir = _parseDir(dir);
263 
#ifdef _WIN32
264 
			if (_rmdir(remDir.c_str()) == 0)
265 
#else
266 
			if (rmdir(remDir.c_str()) == 0)
267 
#endif
268 
			{
269 
				if (errors)
270 
					errors->pushBack(remDir);
271 
			}
272 
			return true;
1 cycrow 273 
		}
160 cycrow 274 
 
275 
		// not empty
276 
		if (doFiles || recursive)
277 
		{
278 
			for (auto itr = list.begin(); itr != list.end(); itr++)
279 
			{
280 
				Utils::String d = (*itr)->str;
281 
				if (d == "." || d == "..")
282 
					continue;
283 
 
284 
				// if its a file
285 
				Utils::String fullFile = dir + "\\" + d;
286 
				if (doFiles && isFile(fullFile))
287 
				{
288 
					Utils::String remFile = _parseDir(fullFile);
289 
					if (remove(remFile.c_str()) == 0)
290 
					{
291 
						if (errors)
292 
							errors->pushBack(remFile);
293 
					}
294 
				}
295 
				else if (recursive && isDir(fullFile))
296 
					removeDir(fullFile, doFiles, recursive, errors);
297 
			}
298 
		}
1 cycrow 299 
	}
160 cycrow 300 
	list.clear();
301 
	// now check if its empty
302 
	if(dirList(list, dir))
303 
	{
304 
		if (checkEmptyDir(list))
305 
		{
306 
			Utils::String remDir = _parseDir(dir);
307 
#ifdef _WIN32
308 
			if (_rmdir(remDir.c_str()) == 0)
309 
#else
310 
			if (rmdir(remDir.c_str()) == 0)
311 
#endif
312 
			{
313 
				if (errors)
314 
					errors->pushBack(remDir);
315 
			}
316 
			return true;
317 
		}
318 
	}
319 
	return false;
1 cycrow 320 
 
160 cycrow 321 
}
322 
bool CDirIO::RemoveDir(CyString dir, bool doFiles, bool recursive, CyStringList* errors)
323 
{
324 
	// check if the dir is empty
325 
	Utils::CStringList list;
326 
	if (dirList(list, dir.ToString()))
1 cycrow 327 
	{
160 cycrow 328 
		if (checkEmptyDir(list))
1 cycrow 329 
		{
160 cycrow 330 
			Utils::String remDir = _parseDir(dir.ToString());
331 
#ifdef _WIN32
332 
			if (_rmdir(remDir.c_str()) == 0)
333 
#else
334 
			if (rmdir(remDir.c_str()) == 0)
335 
#endif
336 
			{
337 
				if (errors)
338 
					errors->PushBack(CyString(remDir));
339 
			}
340 
			return true;
341 
		}
1 cycrow 342 
 
160 cycrow 343 
		// not empty
344 
		if (doFiles || recursive)
345 
		{
346 
			for (auto itr = list.begin(); itr != list.end(); itr++)
1 cycrow 347 
			{
160 cycrow 348 
				Utils::String d = (*itr)->str;
349 
				if (d == "." || d == "..")
350 
					continue;
351 
 
352 
				// if its a file
353 
				Utils::String fullFile = dir.ToString() + "\\" + d;
354 
				if (doFiles && isFile(fullFile))
1 cycrow 355 
				{
160 cycrow 356 
					Utils::String remFile = _parseDir(fullFile);
357 
					if (remove(remFile.c_str()) == 0)
358 
					{
359 
						if (errors)
360 
							errors->PushBack(CyString(remFile));
361 
					}
1 cycrow 362 
				}
160 cycrow 363 
				else if (recursive && isDir(fullFile))
364 
					RemoveDir(fullFile, doFiles, recursive, errors);
1 cycrow 365 
			}
366 
		}
367 
	}
368 
 
160 cycrow 369 
	list.clear();
370 
	if (dirList(list, dir.ToString()))
1 cycrow 371 
	{
160 cycrow 372 
		if (checkEmptyDir(list))
1 cycrow 373 
		{
160 cycrow 374 
			Utils::String remDir = _parseDir(dir.ToString());
375 
#ifdef _WIN32
376 
			if (_rmdir(remDir.c_str()) == 0)
377 
#else
378 
			if (rmdir(remDir.c_str()) == 0)
379 
#endif
380 
			{
381 
				if (errors)
382 
					errors->PushBack(CyString(remDir));
383 
			}
384 
			return true;
1 cycrow 385 
		}
386 
	}
387 
	return false;
388 
}
389 
 
160 cycrow 390 
 
124 cycrow 391 
bool CDirIO::dirList(Utils::CStringList &files, Utils::String dir, Utils::String filePattern) const
392 
{
125 cycrow 393 
	dir = _parseDir(dir);
119 cycrow 394 
	if ( dir.empty() )
124 cycrow 395 
		return false;
119 cycrow 396 
 
121 cycrow 397 
	dir = dir.findReplace("\\", "/");
398 
	if (filePattern.empty())
399 
		dir += "/*";
119 cycrow 400 
	else
401 
	{
121 cycrow 402 
		dir += "/";
119 cycrow 403 
		dir += filePattern;
404 
	}
121 cycrow 405 
	dir = dir.findReplace("//", "/");
119 cycrow 406 
 
121 cycrow 407 
#ifdef _WIN32
408 
	dir = dir.findReplace("/", "\\");
409 
 
119 cycrow 410 
	WIN32_FIND_DATA data;
411 
	TCHAR buf[5000];
412 
	wsprintf(buf, L"%hs", dir.c_str());
413 
 
414 
	HANDLE h = FindFirstFile(buf, &data);
415 
	if ( h != INVALID_HANDLE_VALUE)
416 
	{
417 
		std::wstring ws(data.cFileName);
418 
		std::string s(ws.begin(), ws.end());
419 
 
420 
		Utils::String checkFile(s);
421 
		if ( !checkFile.Compare(".") && !checkFile.Compare("..") )
121 cycrow 422 
			files.pushBack(checkFile);
119 cycrow 423 
 
424 
		while ( FindNextFile(h, &data) )
425 
		{
426 
			std::wstring ws(data.cFileName);
427 
			std::string s(ws.begin(), ws.end());
428 
 
429 
			Utils::String checkFile(s);
430 
			if ( checkFile != "." && checkFile != ".." )
121 cycrow 431 
				files.pushBack(checkFile);
119 cycrow 432 
		}
433 
 
434 
		FindClose(h);
124 cycrow 435 
		return true;
119 cycrow 436 
	}
124 cycrow 437 
	return false;
119 cycrow 438 
#else
121 cycrow 439 
	DIR *dir;
440 
	struct dirent *ent;
441 
	if ((dir = opendir(dir.c_str())) != NULL) {
442 
		while ((ent = readdir(dir)) != NULL) {
443 
			Utils::String checkFile(ent->d_name);
444 
			if (checkFile != "." && checkFile != "..")
445 
				files.pushBack(checkFile);
446 
		}
447 
		closedir(dir);
448 
	}
124 cycrow 449 
	return true;
119 cycrow 450 
#endif//_WIN32
451 
 
452 
}
453 
 
121 cycrow 454 
Utils::String CDirIO::file(const Utils::String &filename) const
455 
{
456 
	if (m_sCurrentDir.empty())
457 
		return filename;
458 
 
459 
	return m_sCurrentDir + "/" + filename;
460 
}
461 
 
85 cycrow 462 
Utils::String CDirIO::dir(const Utils::String &sDir) const
463 
{
125 cycrow 464 
	return _parseDir(sDir);
85 cycrow 465 
}
466 
 
467 
const Utils::String &CDirIO::dir() const
468 
{
469 
	return m_sCurrentDir;
470 
}
471 
 
129 cycrow 472 
bool CDirIO::cd(const Utils::String &sDir)
1 cycrow 473 
{
85 cycrow 474 
	if ( m_sCurrentDir.empty() )
475 
		m_sCurrentDir = sDir;
1 cycrow 476 
	else
85 cycrow 477 
		m_sCurrentDir = m_sCurrentDir + "/" + sDir;
478 
	m_sCurrentDir = m_sCurrentDir.asFilename();
1 cycrow 479 
 
121 cycrow 480 
	return exists();
1 cycrow 481 
}
482 
 
160 cycrow 483 
bool CDirIO::createAndChange(const Utils::String &dir)
1 cycrow 484 
{
160 cycrow 485 
	if ( create(dir) )
486 
		return cd(dir);
1 cycrow 487 
	return false;
488 
}
489 
 
490 
 
121 cycrow 491 
Utils::String CDirIO::topDir() const
1 cycrow 492 
{
85 cycrow 493 
	if ( m_sCurrentDir.empty() )
121 cycrow 494 
		return Utils::String("");
1 cycrow 495 
 
85 cycrow 496 
	return m_sCurrentDir.token("/", -1);
1 cycrow 497 
}
498 
 
125 cycrow 499 
const Utils::String &CDirIO::moveBack()
1 cycrow 500 
{
85 cycrow 501 
	m_sCurrentDir = m_sCurrentDir.tokens("/", 1, -2);
1 cycrow 502 
	return m_sCurrentDir;
125 cycrow 503 
}
504 
Utils::String CDirIO::back() const
505 
{
506 
	return m_sCurrentDir.tokens("/", 1, -2);
507 
}