Initial sources

engine/filesystem/filemanager.cpp

@@ -0,0 +1,316 @@
+#define WIN32_LEAN_AND_MEAN
+#include <Windows.h>
+#include <assert.h>
+#include "filesystem/stream.h"
+#include "filesystem/filemanager.h"
+
+void RecursiveSearch(const std::string& path, std::vector<std::string>& files);
+void osResolvePath(char* path);
+
+FileManager* g_fileManager;
+
+FileManager::FileManager()
+{
+	static char currentDirectory[kMaxPathLength];
+	GetCurrentDirectoryA(kMaxPathLength, currentDirectory);
+	strcat(currentDirectory, "/");
+	
+	osResolvePath(currentDirectory);
+	
+	m_defaultPath = currentDirectory;
+}
+
+FileManager::~FileManager()
+{
+
+}
+
+void FileManager::SetDefaultPath(const char* path)
+{
+	m_defaultPath = path;
+}
+
+bool FileManager::FileExist(const char* filename)
+{
+#if defined(WIN32) || defined(_WIN32)
+	char pathBuffer[kMaxPathLength];
+	if (!strstr(filename, m_defaultPath))
+		sprintf(pathBuffer, "%s%s", m_defaultPath, filename);
+	else
+		strcpy(pathBuffer, filename);
+
+	osResolvePath(pathBuffer);
+
+	DWORD dwAttrib = GetFileAttributes(pathBuffer);
+	return (dwAttrib != 0xffffffff && !(dwAttrib & FILE_ATTRIBUTE_DIRECTORY));
+#else
+	FILE* file;
+
+	if ((file = fopen(filename, "r")) != NULL)
+	{
+		fclose(file);
+		return true;
+}
+	else
+		return false;
+#endif
+}
+
+File* FileManager::OpenFile(const char* path, FileAccess access)
+{
+	char pathBuffer[kMaxPathLength];
+	if (!strstr(path, m_defaultPath))
+		sprintf(pathBuffer, "%s%s", m_defaultPath, path);
+	else
+		strcpy(pathBuffer, path);
+
+	osResolvePath(pathBuffer);
+
+	return new File(pathBuffer, access);
+}
+
+void FileManager::CloseFile(File*& file)
+{
+	if (file)
+	{
+		delete file;
+		file = NULL;
+	}
+}
+
+StreamBase* FileManager::OpenStream(const char* fname, FileAccess access)
+{
+	char pathBuffer[kMaxPathLength];
+	if (!strstr(fname, m_defaultPath))
+		sprintf(pathBuffer, "%s%s", m_defaultPath, fname);
+	else
+		strcpy(pathBuffer, fname);
+
+	osResolvePath(pathBuffer);
+
+	if (!g_fileManager->FileExist( pathBuffer ))
+		return NULL;
+
+	File* file = new File(pathBuffer, access);
+	return CreateFileStream(file);
+}
+
+#if _WIN32
+#include <stdio.h>
+#include <stdlib.h>
+#include <io.h>
+#include <time.h>
+
+void GetFileListFromFolder(const char* path, const char* findingPattern, std::vector<std::string>& filesList)
+{
+	struct _finddata_t c_file;
+	long hFile;
+
+	char pathfind[kMaxPathLength];
+	sprintf(pathfind, "%s/%s", path, findingPattern);
+	osResolvePath(pathfind);
+
+	if ((hFile = _findfirst(pathfind, &c_file)) != -1L) {
+		do {
+			char buffer[kMaxPathLength];
+			sprintf(buffer, "%s/%s", path, c_file.name);
+			filesList.push_back(buffer);
+		} while (_findnext(hFile, &c_file) == 0);
+		_findclose(hFile);
+	}
+}
+
+void osResolvePath(char* path)
+{
+	assert(path);
+
+	size_t length = strlen(path);
+
+	for (int i = 0; i < (int)length; i++) {
+		if (path[i] == '/')
+			path[i] = '\\';
+	}
+}
+
+bool osDirectoryIsExist(const char* path)
+{
+	DWORD ftyp = GetFileAttributesA(path);
+	if (ftyp == 0xffffffff)
+		return false;
+
+	if (ftyp & FILE_ATTRIBUTE_DIRECTORY)
+		return true;
+
+	return false;
+}
+
+void osCreateDirectory(const char* path)
+{
+	CreateDirectoryA(path, NULL);
+}
+
+void RecursiveSearch(const std::string& path, std::vector<std::string>& files)
+{
+	struct _finddata_t c_file;
+	long hFile;
+
+	std::string bufferPath;
+	bufferPath += path;
+	bufferPath += "/";
+	bufferPath += "*.*";
+
+	if ((hFile = _findfirst(bufferPath.c_str(), &c_file)) != -1L)
+	{
+		do {
+			if (strcmp(c_file.name, ".") == 0 ||
+				strcmp(c_file.name, "..") == 0 ||
+				strcmp(c_file.name, ".git") == 0 ||
+				strcmp(c_file.name, ".gitignore") == 0 ||
+				strcmp(c_file.name, ".gitignore") == 0 ||
+				strcmp(c_file.name, ".vs") == 0)
+				continue;
+
+			if (c_file.attrib & _A_SUBDIR)
+			{
+				std::string nextPath;
+				nextPath += path;
+				nextPath += "/";
+				nextPath += c_file.name;
+
+				RecursiveSearch(nextPath, files);
+			}
+			else
+			{
+				std::string filepath;
+				filepath += path;
+				filepath += "/";
+				filepath += c_file.name;
+				files.push_back(filepath);
+			}
+
+		} while (_findnext(hFile, &c_file) == 0);
+		_findclose(hFile);
+	}
+}
+
+#else
+#include <dirent.h>
+
+bool match(const char* pattern, const char* str, int p = 0, int c = 0)
+{
+	if (pattern[p] == '\0')
+	{
+		return str[c] == '\0';
+	}
+	else if (pattern[p] == '*')
+	{
+		for (; str[c] != '\0'; c++)
+		{
+			if (match(pattern, str, p + 1, c))
+				return true;
+		}
+		return match(pattern, str, p + 1, c);
+	}
+	else if (pattern[p] != '?' && pattern[p] != str[c])
+	{
+		return false;
+	}
+	else
+	{
+		return match(pattern, str, p + 1, c + 1);
+	}
+}
+
+void GetFileListFromFolder(const char* path, const char* findingPattern, std::vector<std::string>& filesList)
+{
+	DIR* dir;
+	dirent* ent;
+
+	if ((dir = opendir(path)) != NULL)
+	{
+		while ((ent = readdir(dir)) != NULL)
+		{
+			if (match(findingPattern, ent->d_name))
+			{
+				char buffer[kMaxPathLength];
+				snprintf(buffer, kMaxPathLength, "%s/%s", path, ent->d_name);
+				filesList.push_back(buffer);
+			}
+		}
+
+		closedir(dir);
+	}
+}
+#endif
+
+namespace fs
+{
+	std::string getFileExtension(const std::string& filename)
+	{
+		size_t whereIsDot = filename.find_last_of('.');
+		if (whereIsDot != std::string::npos) {
+			return filename.substr(whereIsDot);
+		}
+
+		return std::string();
+	}
+
+	std::string getFilePath(const std::string& filename)
+	{
+		size_t lastindex = filename.find_last_of("/");
+		if (lastindex == std::string::npos) {
+			lastindex = filename.find_last_of("\\");
+		}
+
+		if (lastindex != std::string::npos) {
+
+			return filename.substr(0, lastindex);
+		}
+
+		return std::string();
+	}
+
+	std::string getFileNameWithoutExtension(const std::string& filename)
+	{
+		size_t lastindex = filename.find_last_of(".");
+		if (lastindex != std::string::npos) {
+			return filename.substr(0, lastindex);
+		}
+
+		return filename;
+	}
+
+	std::string getFilenameWithoutPath(const std::string& filename)
+	{
+		size_t whereIsSlash = filename.find_last_of('/');
+		if (whereIsSlash == std::string::npos) {
+			whereIsSlash = filename.find_last_of('\\');
+		}
+
+		if (whereIsSlash == std::string::npos) {
+			return filename;
+		}
+
+		std::string string = filename.substr(whereIsSlash + 1);
+		return string;
+	}
+
+	std::string getFilenameWithoutPathAndExtension(const std::string& filename)
+	{
+		size_t whereIsDot = filename.find_last_of('.');
+		size_t whereIsSlash = filename.find_last_of('/');
+		if (whereIsSlash == std::string::npos) {
+			whereIsSlash = filename.find_last_of('\\');
+		}
+
+		if (whereIsDot == std::string::npos && whereIsSlash == std::string::npos) {
+			return filename;
+		}
+
+		std::string string = filename.substr(whereIsSlash + 1);
+		whereIsDot = string.find_last_of('.');
+		string = string.substr(0, whereIsDot);
+
+		return string;
+	}
+}