No fs::path return (#8149)

Author: roymacdonald

libs/openFrameworks/graphics/ofImage.cpp

@@ -251,7 +251,7 @@ static bool loadImage(ofPixels_<PixelType> & pix, const of::filesystem::path & _
 		if(fif == FIF_JPEG) {
 			option = getJpegOptionFromImageLoadSetting(settings);
 		}
-		auto fileName = ofToDataPath(_fileName);
+		auto fileName = ofToDataPathFS(_fileName);
 
 #ifdef OF_OS_WINDOWS
 		bmp = FreeImage_LoadU(fif, fileName.c_str(), option | settings.freeImageFlags);
@@ -420,7 +420,7 @@ static bool saveImage(const ofPixels_<PixelType> & _pix, const of::filesystem::p
 	}
 
 	ofFilePath::createEnclosingDirectory(_fileName);
-	auto fileName = ofToDataPath(_fileName);
+	auto fileName = ofToDataPathFS(_fileName);
 	FREE_IMAGE_FORMAT fif = FIF_UNKNOWN;
 #ifdef OF_OS_WINDOWS
 	fif = FreeImage_GetFileTypeU(fileName.c_str(), 0);

libs/openFrameworks/graphics/ofTrueTypeFont.cpp

@@ -368,7 +368,7 @@ static of::filesystem::path linuxFontPathByName(const string & fontname) {
 static bool loadFontFace(const string & _fontname, FT_Face & face,
 						 of::filesystem::path & _filename, int index){
 	auto fontname = _fontname;
-	auto filename = ofToDataPath(fontname);
+	auto filename = ofToDataPathFS(fontname);
 	int fontID = index;
 	if(!of::filesystem::exists(filename)){
 #ifdef TARGET_LINUX

libs/openFrameworks/utils/ofFileUtils.cpp

@@ -29,24 +29,24 @@ namespace{
 	fs::path defaultDataPath(){
 	#if defined TARGET_OSX
 		try {
-			return fs::canonical(ofFilePath::getCurrentExeDir() / "../../../data/");
+			return fs::canonical(ofFilePath::getCurrentExeDirFS() / "../../../data/");
 		} catch(...) {
-			return ofFilePath::getCurrentExeDir() / "../../../data/";
+			return ofFilePath::getCurrentExeDirFS() / "../../../data/";
 		}
 	#elif defined TARGET_ANDROID
 		return string("sdcard/");
 	#else
 		try {
-            return fs::canonical(ofFilePath::getCurrentExeDir() / "data/").make_preferred();
+            return fs::canonical(ofFilePath::getCurrentExeDirFS() / "data/").make_preferred();
         } catch(...) {
-			return (ofFilePath::getCurrentExeDir() / "data/");
+			return (ofFilePath::getCurrentExeDirFS() / "data/");
 		}
 	#endif
 	}
 
 	//--------------------------------------------------
 	fs::path & defaultWorkingDirectory() {
-		static auto * defaultWorkingDirectory = new fs::path(ofFilePath::getCurrentExeDir());
+		static auto * defaultWorkingDirectory = new fs::path(ofFilePath::getCurrentExeDirFS());
 		return * defaultWorkingDirectory;
 	}
 
@@ -558,7 +558,7 @@ bool ofFile::openStream(Mode _mode, bool _binary){
 //------------------------------------------------------------------------------------------------------------
 bool ofFile::open(const fs::path & _path, Mode _mode, bool binary){
 	close();
-	myFile = ofToDataPath(_path);
+	myFile = ofToDataPathFS(_path);
 	return openStream(_mode, binary);
 }
 
@@ -648,10 +648,15 @@ bool ofFile::exists() const {
 }
 
 //------------------------------------------------------------------------------------------------------------
-fs::path ofFile::path() const {
+fs::path ofFile::pathFS() const {
 	return myFile;
 }
 
+//------------------------------------------------------------------------------------------------------------
+std::string ofFile::path() const {
+	return ofPathToString(pathFS());
+}
+
 //------------------------------------------------------------------------------------------------------------
 // FIXME: Deprecate
 string ofFile::getExtension() const {
@@ -675,12 +680,14 @@ string ofFile::getBaseName() const {
 }
 
 //------------------------------------------------------------------------------------------------------------
-fs::path ofFile::getEnclosingDirectory() const {
+// MARK: - near future FS
+std::string ofFile::getEnclosingDirectory() const {
 	return ofFilePath::getEnclosingDirectory(path());
 }
 
 //------------------------------------------------------------------------------------------------------------
-fs::path ofFile::getAbsolutePath() const {
+// MARK: - near future FS
+std::string ofFile::getAbsolutePath() const {
 	return ofFilePath::getAbsolutePath(path());
 }
 
@@ -921,7 +928,7 @@ bool ofFile::copyTo(const fs::path & _path, bool bRelativeToData, bool overwrite
 
 	//bRelativeToData is handled here for the destination path - so we pass false to static functions below
 	if(bRelativeToData){
-		path = ofToDataPath(path);
+		path = ofToDataPathFS(path);
 	}
 
 	if(ofFile::doesFileExist(path, false)){
@@ -971,7 +978,7 @@ bool ofFile::moveTo(const fs::path& _path, bool bRelativeToData, bool overwrite)
 	}
 
 	if(bRelativeToData){
-		path = ofToDataPath(path);
+		path = ofToDataPathFS(path);
 	}
 	if(ofFile::doesFileExist(path, false)){
 
@@ -1157,14 +1164,14 @@ ofDirectory::ofDirectory(const fs::path & path){
 
 //------------------------------------------------------------------------------------------------------------
 void ofDirectory::open(const fs::path & path){
-	originalDirectory = ofFilePath::getPathForDirectory(path);
+	originalDirectory = ofFilePath::getPathForDirectoryFS(path);
 	files.clear();
-	myDir = ofToDataPath(originalDirectory);
+	myDir = ofToDataPathFS(originalDirectory);
 }
 
 //------------------------------------------------------------------------------------------------------------
 void ofDirectory::openFromCWD(const fs::path & path){
-	originalDirectory = ofFilePath::getPathForDirectory(path);
+	originalDirectory = ofFilePath::getPathForDirectoryFS(path);
 	files.clear();
 	myDir = originalDirectory;
 }
@@ -1206,14 +1213,20 @@ std::string ofDirectory::path() const {
 }
 
 //------------------------------------------------------------------------------------------------------------
-fs::path ofDirectory::getAbsolutePath() const {
+fs::path ofDirectory::getAbsolutePathFS() const {
 	try {
 		return fs::canonical(fs::absolute(myDir));
 	} catch(...) {
 		return fs::absolute(myDir);
 	}
 }
 
+// MARK: - near future FS
+//------------------------------------------------------------------------------------------------------------
+std::string ofDirectory::getAbsolutePath() const {
+	return ofPathToString(ofDirectory::getAbsolutePathFS());
+}
+
 //------------------------------------------------------------------------------------------------------------
 bool ofDirectory::canRead() const {
 	return ofFile(myDir,ofFile::Reference).canRead();
@@ -1283,7 +1296,7 @@ bool ofDirectory::copyTo(const fs::path & _path, bool bRelativeToData, bool over
 	}
 
 	if(bRelativeToData){
-		path = ofToDataPath(path, bRelativeToData);
+		path = ofToDataPathFS(path, bRelativeToData);
 	}
 
 	if(ofDirectory::doesDirectoryExist(path, false)){
@@ -1587,7 +1600,7 @@ bool ofDirectory::createDirectory(const fs::path& _dirPath, bool bRelativeToData
 	auto dirPath = _dirPath;
 
 	if(bRelativeToData){
-		dirPath = ofToDataPath(dirPath);
+		dirPath = ofToDataPathFS(dirPath);
 	}
 
 	// on OSX,fs::create_directories seems to return false *if* the path has folders that already exist
@@ -1621,7 +1634,7 @@ bool ofDirectory::doesDirectoryExist(const fs::path& _dirPath, bool bRelativeToD
 	auto dirPath = _dirPath;
 	try {
 		if (bRelativeToData) {
-			dirPath = ofToDataPath(dirPath);
+			dirPath = ofToDataPathFS(dirPath);
 		}
 		return fs::exists(dirPath) && fs::is_directory(dirPath);
 	}
@@ -1635,7 +1648,7 @@ bool ofDirectory::doesDirectoryExist(const fs::path& _dirPath, bool bRelativeToD
 bool ofDirectory::isDirectoryEmpty(const fs::path& _dirPath, bool bRelativeToData){
 	auto dirPath = _dirPath;
 	if(bRelativeToData){
-		dirPath = ofToDataPath(dirPath);
+		dirPath = ofToDataPathFS(dirPath);
 	}
 
 	if(!dirPath.empty() && fs::exists(dirPath) && fs::is_directory(dirPath)){
@@ -1750,7 +1763,7 @@ std::string ofFilePath::removeExt(const fs::path & _filename){
 }
 
 //------------------------------------------------------------------------------------------------------------
-fs::path ofFilePath::getPathForDirectory(const fs::path & path){
+fs::path ofFilePath::getPathForDirectoryFS(const fs::path & path){
 	// if a trailing slash is missing from a path, this will clean it up
 	// if it's a windows-style "\" path it will add a "\"
 	// if it's a unix-style "/" path it will add a "/"
@@ -1769,11 +1782,18 @@ fs::path ofFilePath::getPathForDirectory(const fs::path & path){
 }
 
 
+//------------------------------------------------------------------------------------------------------------
+// FIXME: Deprecate this seems over complicated and not useful anymore, using filesystem
+string ofFilePath::getPathForDirectory(const fs::path & path){
+	return ofPathToString(ofFilePath::getPathForDirectoryFS(path));
+}
+
+
 //------------------------------------------------------------------------------------------------------------
 // FIXME: - re-avail
 string ofFilePath::removeTrailingSlash(const fs::path & _path){
 	auto path = ofPathToString(_path);
-	if(!path.empty() && (path[path.length() - 1] == '/' || path[path.length() - 1] == '\\')){
+	if(path.length() > 0 && (path[path.length() - 1] == '/' || path[path.length() - 1] == '\\')){
 		path = path.substr(0, path.length() - 1);
 	}
 	return path;
@@ -1797,7 +1817,9 @@ string ofFilePath::getBaseName(const fs::path & filePath){
 }
 
 //------------------------------------------------------------------------------------------------------------
-fs::path ofFilePath::getEnclosingDirectory(const fs::path & _filePath, bool bRelativeToData){
+// MARK: - near future FS
+//fs::path ofFilePath::getEnclosingDirectoryFS(const fs::path & _filePath, bool bRelativeToData){
+std::string ofFilePath::getEnclosingDirectory(const fs::path & _filePath, bool bRelativeToData){
 	auto fp = _filePath;
 	if(bRelativeToData){
 		fp = ofToDataPath(fp);
@@ -1811,7 +1833,8 @@ bool ofFilePath::createEnclosingDirectory(const fs::path& filePath, bool bRelati
 }
 
 //------------------------------------------------------------------------------------------------------------
-fs::path ofFilePath::getAbsolutePath(const fs::path & path, bool bRelativeToData){
+// MARK: - near future FS
+fs::path ofFilePath::getAbsolutePathFS(const fs::path & path, bool bRelativeToData){
 	if(bRelativeToData){
 		return ofToDataPath(path, true);
 	}else{
@@ -1823,6 +1846,11 @@ fs::path ofFilePath::getAbsolutePath(const fs::path & path, bool bRelativeToData
 	}
 }
 
+//------------------------------------------------------------------------------------------------------------
+std::string ofFilePath::getAbsolutePath(const fs::path& path, bool bRelativeToData){
+	return ofPathToString(ofFilePath::getAbsolutePathFS(path, bRelativeToData));
+}
+
 //------------------------------------------------------------------------------------------------------------
 bool ofFilePath::isAbsolute(const fs::path& path){
 	return fs::path(path).is_absolute();
@@ -1841,7 +1869,7 @@ std::string ofFilePath::join(const fs::path& path1, const fs::path& path2){
 }
 
 //------------------------------------------------------------------------------------------------------------
-fs::path ofFilePath::getCurrentExePath(){
+fs::path ofFilePath::getCurrentExePathFS(){
 	#if defined(TARGET_LINUX) || defined(TARGET_ANDROID)
 		char buff[FILENAME_MAX];
 		ssize_t size = readlink("/proc/self/exe", buff, sizeof(buff) - 1);
@@ -1860,27 +1888,31 @@ fs::path ofFilePath::getCurrentExePath(){
 		}
 		return path;
 	#elif defined(TARGET_WIN32)
-		wchar_t filename[MAX_PATH];
-		DWORD result = ::GetModuleFileName(
-			nullptr,    // retrieve path of current process .EXE
-			filename,
-			_countof(filename)
-		);
+		vector<char> executablePath(MAX_PATH);
+		DWORD result = ::GetModuleFileNameA(nullptr, &executablePath[0], static_cast<DWORD>(executablePath.size()));
 		if (result == 0) {
-			// Error
-			ofLogError("ofFilePath") << "getCurrentExePath(): couldn't get path, GetModuleFileName failed";
+			ofLogError("ofFilePath") << "getCurrentExePath(): couldn't get path, GetModuleFileNameA failed";
+		} else {
+			return string(executablePath.begin(), executablePath.begin() + result);
 		}
-		return filename;
 	#endif
-	return {};
+	return "";
 }
 
+//------------------------------------------------------------------------------------------------------------
+std::string ofFilePath::getCurrentExePath(){
+	return ofPathToString(getCurrentExePathFS());
+}
 
 //------------------------------------------------------------------------------------------------------------
-fs::path ofFilePath::getCurrentExeDir(){
-	return ofFilePath::getCurrentExePath().parent_path() / "";
+fs::path ofFilePath::getCurrentExeDirFS(){
+	return ofFilePath::getCurrentExePathFS().parent_path() / "";
 }
 
+//------------------------------------------------------------------------------------------------------------
+std::string ofFilePath::getCurrentExeDir(){
+	return ofPathToString(getCurrentExeDirFS());
+}
 
 //------------------------------------------------------------------------------------------------------------
 string ofFilePath::getUserHomeDir(){
@@ -1929,7 +1961,7 @@ void ofSetDataPathRoot(const fs::path& newRoot){
 }
 
 //--------------------------------------------------
-fs::path ofToDataPath(const fs::path & path, bool makeAbsolute){
+fs::path ofToDataPathFS(const fs::path & path, bool makeAbsolute){
 	if (makeAbsolute && path.is_absolute()) {
 		return path;
 	}
@@ -2019,6 +2051,10 @@ fs::path ofToDataPath(const fs::path & path, bool makeAbsolute){
 	}
 }
 
+//--------------------------------------------------
+std::string ofToDataPath(const fs::path & path, bool makeAbsolute){
+	return ofPathToString(ofToDataPathFS(path, makeAbsolute));
+}
 
 //--------------------------------------------------
 // Function used internally in OF core. API can change later