Functions
void	debugBreak ()
	debugBreak Forces the debugger to break/halt the application when this is called. More...

void	printToConsole (const std::string &str)
	printToConsole A convenience function for printing a string to the command-line console. More...

void	printToAllScriptConsoleWidgets (const std::string &str)
	printToAllScriptConsoleWidgets A convenience function for printing a string to all the GUI console widgets in the application More...

void	messageBox (const std::string &str)
	messageBox A convenience function for displaying a message box containing a message. More...

void	processApplicationEvents ()
	processApplicationEvents Processes all pending application events for the calling thread. More...

bool	fileExists (const std::string &filePath)
	fileExists Checks if a file exists, returns true if it does. More...

bool	directoryExists (const std::string &dirPath)
	directoryExists Checks if a directory exists, returns true if it does. More...

bool	directoryContainsFile (const std::string &dirPath, const std::string &fileName)
	directoryContainsFile Checks if the directory contains the given file, returns true if it does. More...

std::string	readFileAsString (const std::string &filePath)
	readFileAsString Reads a file, returning a string containing the contents. More...

std::vector< std::string >	getFilePathsForDirectory (const std::string &dirPath)
	getFilePathsForDirectory Gets the absolute file paths to the files in the given directory. More...

std::vector< std::string >	getSubdirectoriesForDirectory (const std::string &dirPath)
	getSubdirectoriesForDirectory Gets the absolute paths for direct subdirectories of the given directory. More...

bool	endsWith (const std::string &value, const std::string &ending)

std::vector< std::string >	getFilesWithExtension (const std::string &dirPath, const std::string &extension)
	getFilesWithExtension Gets the absolute file paths to the files with the given extension in the given directory. More...

std::string	getFirstFileWithExtension (const std::string &dirPath, const std::string &extension)
	getFirstFileWithExtension Gets the absolute file path to the first file with the given extension in the given directory. More...

std::string	getFirstFileWithExtensions (const std::string &dirPath, const std::vector< std::string > &extensions)
	getFirstFileWithExtensions Gets the absolute file path to the first file with one of the given extensions in the given directory. More...

std::vector< std::string >	getScriptsForPath (const std::string &path)
	getScriptsForPath Gets the absolute file paths to the script files (*.chai) for the given directory, using recursive search. More...

std::string	getDirectoryForFilePath (const std::string &filePath)
	getDirectoryForFilePath Gets the directory path from the given local file path. More...

bool	openInDefaultApplication (const std::string &path)
	openInDefaultApplication Opens the given path in the default application. More...

bool	revealInDefaultApplication (const std::string &path)
	revealInDefaultApplication Reveals the given path in the parent folder (or path with the filename trimmed). More...

void	clearGlobalClipboard ()
	clearGlobalClipboard Clears the global system clipboard contents. More...

std::string	getGlobalClipboardText ()
	getGlobalClipboardText Gets the global system clipboard text. More...

void	setGlobalClipboardText (const std::string &text)
	setClipboardText Sets the global system clipboard text. More...

bool	stringBeginsWith (const std::string &str, const std::string &prefix)
	stringBeginsWith Checks if a string begins with the given prefix. More...

bool	stringEndsWith (const std::string &str, const std::string &suffix)
	stringEndsWith Checks if a string ends with the given suffix. More...

std::string	getApplicationDirectoryLocation ()
	getApplicationDirectory Get directory that the application is in. More...

std::string	getAppDataLocation ()
	getAppDataLocation Returns a directory location where persistent application data can be stored. More...

std::string	getHomeDirectoryLocation ()
	getHomeDirectoryLocation Returns a path to where the user's home directory is. More...

bool	writeStringToFile (const std::string &str, const std::string &path)
	writeStringToFile Writes the string to the file path, attempting to overwrite any existing file at the path. More...

std::string	percentEncode (const std::string &str)
	percentEncode Returns a percent-encoded copy of the input string. More...

int	randomInRange (int lower, int upper)
	randomInRange Returns a random integer in the range [lower, upper], inclusive. Note that this uses thread-local RNGs under the hood. This must not be called on the same thread as the Geometrize shape mutation code - otherwise the shape generation may not be deterministic. More...

std::vector< std::string >	split (const std::string &s, char delimiter)
	split Splits a given string into a vector of tokens using the given delimiter. More...

int	getCursorX ()
	getCursorX Gets the x-coordinate of the cursor in global screen coordinates. More...

int	getCursorY ()
	getCursorY Gets the y-coordinate of the cursor in global screen coordinates. More...

void	setCursorPos (int x, int y)
	setCursorPos Sets the cursor position in global screen coordinates. More...

std::string	getOperatingSystemProductType ()
	getOperatingSystemProductType Returns the product name of the operating system this application is running in. More...

bool	saveWidgetScreenshot (const std::string &path, QWidget *widget)
	saveWidgetScreenshot Takes a screenshot of the given widget and saves it as a .png image to the given path. More...

template<typename T >
T	clamp (T value, T lower, T upper)
	clamp Clamps a value within a range. More...

template<typename T >
void	split (const std::string &s, const char delimiter, T result)

std::vector< std::string >	readStringVector (const std::string &filePath)
	readStringVector Reads the JSON file containing the vector of strings at the given filepath. Will attempt to overwrite any existing file when it does this. More...

void	writeStringVector (const std::vector< std::string > &vec, const std::string &filePath)
	writeStringVector Writes the string vector to the given filepath as JSON. Will attempt to overwrite any existing file. More...

void	openTask (const QString &urlStr, bool addToRecents)

void	openTasks (const QStringList &urls, const bool addToRecents)

bool	openTemplate (chaiscript::ChaiScript &engine, const std::string &templateFolder)

TemplateManifest	getTemplateManifest (const std::string &templateFolder)

Function Documentation

template<typename T >

T geometrize::util::clamp	(	T	value,
		T	lower,
		T	upper
	)

clamp Clamps a value within a range.

Parameters

value	The value to clamp.
lower	The lower bound of the range.
upper	The upper bound of the range.

Returns: The clamped value.

 {
     assert(lower <= upper);
     if (value < lower) {
         value = lower;
     }
     if (value > upper) {
         value = upper;
     }
     return value;
 }

Here is the caller graph for this function:

void geometrize::util::clearGlobalClipboard ( )

clearGlobalClipboard Clears the global system clipboard contents.

 {
     QApplication::clipboard()->clear();
 }

Here is the caller graph for this function:

void geometrize::util::debugBreak ( )

debugBreak Forces the debugger to break/halt the application when this is called.

 {
 #ifdef _MSC_VER
     __debugbreak();
 #elif __MINGW32__
     // Not sure how to break here...
     assert(0 && "Mingw32 debug break");
 #else
     raise(SIGTRAP);
 #endif
 }

Here is the caller graph for this function:

bool geometrize::util::directoryContainsFile	(	const std::string &	dirPath,
		const std::string &	fileName
	)

directoryContainsFile Checks if the directory contains the given file, returns true if it does.

Returns: True if the directory contains the given file, false otherwise.

 {
     const QString qFileName{QString::fromStdString(fileName)};
     QDirIterator it(QString::fromStdString(dirPath));
     while(it.hasNext()) {
         it.next();
         if(QFileInfo(it.filePath()).isFile()) {
             if(it.fileName() == qFileName) {
                 return true;
             }
         }
     }
     return false;
 }

Here is the caller graph for this function:

bool geometrize::util::directoryExists ( const std::string & dirPath )

directoryExists Checks if a directory exists, returns true if it does.

Parameters

dirPath The directory path.

Returns: True if the directory exists, false if it does not.

 {
     return QDir(QString::fromStdString(dirPath)).exists();
 }

Here is the caller graph for this function:

bool geometrize::util::endsWith	(	const std::string &	value,
		const std::string &	ending
	)

inline

 {
     if (value.length() >= ending.length()) {
         return (0 == value.compare (value.length() - ending.length(), ending.length(), ending));
     } else {
         return false;
     }
 }

Here is the caller graph for this function:

bool geometrize::util::fileExists ( const std::string & filePath )

fileExists Checks if a file exists, returns true if it does.

Parameters

filePath The file path.

Returns: True if the file exists, false if it does not.

 {
     return QFile(QString::fromStdString(filePath)).exists();
 }

Here is the caller graph for this function:

std::string geometrize::util::getAppDataLocation ( )

getAppDataLocation Returns a directory location where persistent application data can be stored.

Returns: Directory location where persistent application data can be stored.

 {
     return QStandardPaths::writableLocation(QStandardPaths::GenericDataLocation).toStdString();
 }

Here is the caller graph for this function:

std::string geometrize::util::getApplicationDirectoryLocation ( )

getApplicationDirectory Get directory that the application is in.

Returns: Get application directory.

 {
     return QCoreApplication::applicationDirPath().toStdString();
 }

Here is the caller graph for this function:

int geometrize::util::getCursorX ( )

getCursorX Gets the x-coordinate of the cursor in global screen coordinates.

Returns: The x-coordinate of the cursor.

 {
     return QCursor::pos().x();
 }

Here is the caller graph for this function:

int geometrize::util::getCursorY ( )

getCursorY Gets the y-coordinate of the cursor in global screen coordinates.

Returns: The y-coordinate of the cursor.

 {
     return QCursor::pos().y();
 }

Here is the caller graph for this function:

std::string geometrize::util::getDirectoryForFilePath ( const std::string & filePath )

getDirectoryForFilePath Gets the directory path from the given local file path.

Parameters

filePath The filepath to chop.

Returns: The directory path i.e. the file path with the file name and any trailing slashes removed.

 {
     const QFileInfo fileInfo{QString::fromStdString(filePath)};
 
     if(!fileInfo.exists()) {
         assert(0 && "File does not exist");
     }
 
     return fileInfo.absoluteDir().absolutePath().toStdString();
 }

std::vector< std::string > geometrize::util::getFilePathsForDirectory ( const std::string & dirPath )

getFilePathsForDirectory Gets the absolute file paths to the files in the given directory.

Parameters

dirPath The directory to search.

Returns: A vector of files.

 {
     std::vector<std::string> files;
 
     QDirIterator it(QString::fromStdString(dirPath));
     while(it.hasNext()) {
         it.next();
         if(QFileInfo(it.filePath()).isFile()) {
             files.push_back(it.filePath().toStdString());
         }
     }
     return files;
 }

Here is the caller graph for this function:

std::vector< std::string > geometrize::util::getFilesWithExtension	(	const std::string &	dirPath,
		const std::string &	extension
	)

getFilesWithExtension Gets the absolute file paths to the files with the given extension in the given directory.

Parameters

dirPath	The directory to search.
extension	The file extension to match.

Returns: The file paths to the files encountered, empty vector if there are no matching files. The order of the file paths is implementation-dependent.

 {
     std::vector<std::string> files{getFilePathsForDirectory(dirPath)};
 
     files.erase(std::remove_if(files.begin(), files.end(), [&extension](const std::string& s) {
         return !endsWith(s, extension);
     }), files.end());
 
     return files;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

std::string geometrize::util::getFirstFileWithExtension	(	const std::string &	dirPath,
		const std::string &	extension
	)

getFirstFileWithExtension Gets the absolute file path to the first file with the given extension in the given directory.

Parameters

dirPath	The directory to search.
extension	The file extension to match.

Returns: The file path to the first matching file encountered, empty string if there are no matching files. The 'first' file is implementation-dependent.

 {
     const std::vector<std::string> files{getFilesWithExtension(dirPath, extension)};
 
     if(files.empty()) {
         return "";
     }
     return files.front();
 }

Here is the call graph for this function:

Here is the caller graph for this function:

std::string geometrize::util::getFirstFileWithExtensions	(	const std::string &	dirPath,
		const std::vector< std::string > &	extensions
	)

getFirstFileWithExtensions Gets the absolute file path to the first file with one of the given extensions in the given directory.

Parameters

dirPath	The directory to search.
extensions	The file extension to match.

Returns: The file path to the first matching file encountered, empty string if there are no matching files. The 'first' file is implementation-dependent.

 {
     for(const std::string& ext : extensions) {
         const std::string s{getFirstFileWithExtension(dirPath, ext)};
         if(!s.empty()) {
             return s;
         }
     }
 
     return "";
 }

Here is the call graph for this function:

Here is the caller graph for this function:

std::string geometrize::util::getGlobalClipboardText ( )

getGlobalClipboardText Gets the global system clipboard text.

Returns: The global system clipboard text, or an empty string if the clipboard does not contain any text.

 {
     return QApplication::clipboard()->text().toStdString();
 }

Here is the caller graph for this function:

std::string geometrize::util::getHomeDirectoryLocation ( )

getHomeDirectoryLocation Returns a path to where the user's home directory is.

Returns: Location of the user's home directory.

 {
     return QStandardPaths::writableLocation(QStandardPaths::HomeLocation).toStdString();
 }

Here is the caller graph for this function:

std::string geometrize::util::getOperatingSystemProductType ( )

getOperatingSystemProductType Returns the product name of the operating system this application is running in.

Returns: The name of the operating system: "windows", "osx", "linux", "android", "ios", "tvos" etc

 {
     return QSysInfo::productType().toStdString();
 }

Here is the caller graph for this function:

std::vector< std::string > geometrize::util::getScriptsForPath ( const std::string & path )

getScriptsForPath Gets the absolute file paths to the script files (*.chai) for the given directory, using recursive search.

Parameters

dirPath The directory to search.

Returns: The absolute file paths to the script files for the given directory.

 {
     std::vector<std::string> scripts;
     if(!util::directoryExists(dirPath)) {
         assert(0 && "Script directory does not exist");
         return scripts;
     }
 
     QDirIterator it(QString::fromStdString(dirPath), { "*.chai" }, QDir::Files, QDirIterator::Subdirectories);
     while (it.hasNext()) {
         scripts.push_back(it.next().toStdString());
     }
 
     return scripts;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

std::vector< std::string > geometrize::util::getSubdirectoriesForDirectory ( const std::string & dirPath )

getSubdirectoriesForDirectory Gets the absolute paths for direct subdirectories of the given directory.

Parameters

dirPath The directory to search.

Returns: A vector of directory paths.

 {
     std::vector<std::string> files;
 
     QDirIterator it(QString::fromStdString(dirPath));
     while(it.hasNext()) {
         it.next();
         if(QFileInfo(it.filePath()).isDir()) {
             files.push_back(it.filePath().toStdString());
         }
     }
     return files;
 }

Here is the caller graph for this function:

TemplateManifest geometrize::util::getTemplateManifest ( const std::string & templateFolder )

 {
     return TemplateManifest(util::getFirstFileWithExtensions(templateFolder, format::getSupportedTemplateManifestFileExtensions()));
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void geometrize::util::messageBox ( const std::string & str )

messageBox A convenience function for displaying a message box containing a message.

Parameters

str	The string to display in the message box.

 {
     QMessageBox msgBox;
     msgBox.setText(QString::fromStdString(str));
     msgBox.exec();
 }

Here is the caller graph for this function:

bool geometrize::util::openInDefaultApplication ( const std::string & path )

openInDefaultApplication Opens the given path in the default application.

Parameters

path	The path to the resource to open.

Returns: True if the directory, file, URL (or whatever) should open, else false.

 {
     return QDesktopServices::openUrl(QUrl::fromUserInput(QString::fromStdString(path)));
 }

Here is the caller graph for this function:

void geometrize::util::openTask	(	const QString &	urlStr,
		bool	addToRecents
	)

 {
     if(urlStr.length() == 0) {
         return;
     }
 
     if(addToRecents) {
         geometrize::getRecentItems().add(urlStr, urlStr);
     }
 
     const QUrl url{QUrl::fromUserInput(urlStr)};
     if(url.isLocalFile()) {
         geometrize::task::createImageTaskAndWindow(url.toLocalFile().toStdString(), url.toLocalFile().toStdString());
         return;
     }
 
     std::vector<std::string> imageExtensions{format::getReadableImageFileExtensions(true)};
     for(const std::string& ext : imageExtensions) {
         if(url.toString().endsWith(QString::fromStdString(ext), Qt::CaseInsensitive)) {
             network::downloadImage(url, network::completionhandlers::onImageDownloadComplete);
             return;
         }
     }
 
     network::downloadWebpage(url, network::completionhandlers::onWebpageDownloadComplete);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void geometrize::util::openTasks	(	const QStringList &	urls,
		const bool	addToRecents
	)

 {
     for(const QString& url : urls) {
         openTask(url, addToRecents);
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

bool geometrize::util::openTemplate	(	chaiscript::ChaiScript &	engine,
		const std::string &	templateFolder
	)

 {
     const std::vector<std::string> scripts{util::getScriptsForPath(templateFolder)};
     if(scripts.empty()) {
         // Could not find script for template, so assume it's an image task
         const std::string imageFile{util::getFirstFileWithExtensions(templateFolder, format::getReadableImageFileExtensions(true))};
         if(imageFile.empty()) {
             return false;
         }
 
         geometrize::task::ImageTask* task{task::createImageTaskAndWindow(imageFile, imageFile)};
 
         // Apply settings file if a default one is available
         const std::string settingsFile{geometrize::searchpaths::getDefaultTaskSettingsFilename()};
         if(util::directoryContainsFile(templateFolder, settingsFile)) {
             const std::string settingsPath{QDir(QString::fromStdString(templateFolder)).filePath(QString::fromStdString(settingsFile)).toStdString()};
             const preferences::ImageTaskPreferences prefs(settingsPath);
             task->setPreferences(prefs);
         }
 
         return true;
     }
 
     const std::string script{util::readFileAsString(scripts.front())};
     engine.set_global(chaiscript::var(templateFolder), "templateDirectory");
     geometrize::script::runScript(script, engine);
 
     return true;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

std::string geometrize::util::percentEncode ( const std::string & str )

percentEncode Returns a percent-encoded copy of the input string.

Parameters

str	The input string, to be percent-encoded.

Returns: The percent-encoded input string.

 {
     const QString s{QString::fromStdString(str)};
     const QString percentEncoded{QUrl::toPercentEncoding(s)};
     return percentEncoded.toStdString();
 }

Here is the caller graph for this function:

void geometrize::util::printToAllScriptConsoleWidgets ( const std::string & str )

printToAllScriptConsoleWidgets A convenience function for printing a string to all the GUI console widgets in the application

Parameters

str	The string to print to the script console widgets.

 {
     const auto& allWidgets = QApplication::topLevelWidgets();
     for (const auto& widget : allWidgets) {
         const auto& consoles = widget->findChildren<geometrize::dialog::ScriptConsole*>();
         for(auto& console : consoles) {
             console->appendString(str);
         }
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void geometrize::util::printToConsole ( const std::string & str )

printToConsole A convenience function for printing a string to the command-line console.

Parameters

str	The string to print to the console.

 {
     QTextStream(stdout) << QString::fromStdString(str);
 }

Here is the caller graph for this function:

void geometrize::util::processApplicationEvents ( )

processApplicationEvents Processes all pending application events for the calling thread.

 {
     QCoreApplication* app = QCoreApplication::instance();
     if(app == nullptr) {
         assert(0 && "Application instance pointer is null");
         return;
     }
     app->processEvents();
 }

Here is the caller graph for this function:

int geometrize::util::randomInRange	(	int	lower,
		int	upper
	)

randomInRange Returns a random integer in the range [lower, upper], inclusive. Note that this uses thread-local RNGs under the hood. This must not be called on the same thread as the Geometrize shape mutation code - otherwise the shape generation may not be deterministic.

Parameters

lower	The minimum value.
upper	The maximum value.

Returns: An integer in the range [lower, upper] inclusive.

 {
     assert(lower <= upper);
     return geometrize::commonutil::randomRange(lower, upper);
 }

Here is the caller graph for this function:

std::string geometrize::util::readFileAsString ( const std::string & filePath )

readFileAsString Reads a file, returning a string containing the contents.

Parameters

filePath The path to the file.

Returns: The contents of the file, as a string.

 {
     QFile file(QString::fromStdString(filePath));
 
     if(file.exists() && file.open(QIODevice::ReadOnly | QIODevice::Text)) {
         return QString(file.readAll()).toStdString();
     }
 
     return "";
 }

Here is the caller graph for this function:

std::vector< std::string > geometrize::util::readStringVector ( const std::string & filePath )

readStringVector Reads the JSON file containing the vector of strings at the given filepath. Will attempt to overwrite any existing file when it does this.

Parameters

filePath The path to the file to read.

Returns: The vector of strings read from the file.

 {
     if(!geometrize::util::stringEndsWith(filePath, ".json")) {
         assert(0 && "Failed to read string vector, check file extension");
     }
 
     std::vector<std::string> result;
     std::ifstream file(filePath);
     if(!file) {
         return result;
     }
 
     cereal::JSONInputArchive archive(file);
     archive(result);
     return result;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

bool geometrize::util::revealInDefaultApplication ( const std::string & path )

revealInDefaultApplication Reveals the given path in the parent folder (or path with the filename trimmed).

Parameters

path	The path to the resource to view.

Returns: True if the file, folder, URL (or whatever) should be revealed, else false.

 {
     const QUrl directoryPath{QUrl::fromUserInput(QString::fromStdString(path)).adjusted(QUrl::RemoveFilename)};
     return QDesktopServices::openUrl(directoryPath);
 }

Here is the caller graph for this function:

bool geometrize::util::saveWidgetScreenshot	(	const std::string &	path,
		QWidget *	widget
	)

saveWidgetScreenshot Takes a screenshot of the given widget and saves it as a .png image to the given path.

Parameters

path	The file path to save the screenshot to.
widget	The widget to take a screenshot of.

Returns: True if the screenshot was taken and save successfully, else false.

 {
     return widget->grab().save(QString::fromStdString(path), "png");
 }

Here is the caller graph for this function:

void geometrize::util::setCursorPos	(	int	x,
		int	y
	)

setCursorPos Sets the cursor position in global screen coordinates.

Parameters

x	The x-coordinate of the cursor.
y	The y-coordinate of the cursor.

 {
     QCursor::setPos(x, y);
 }

Here is the caller graph for this function:

void geometrize::util::setGlobalClipboardText ( const std::string & text )

setClipboardText Sets the global system clipboard text.

Parameters

text	The text to set as the clipboard text.

 {
     QApplication::clipboard()->setText(QString::fromStdString(text));
 }

Here is the caller graph for this function:

template<typename T >

void geometrize::util::split	(	const std::string &	s,
		const char	delimiter,
		T	result
	)

 {
     std::stringstream ss;
     ss.str(s);
     std::string item;
     while (std::getline(ss, item, delimiter)) {
         *(result++) = item;
     }
 }

std::vector< std::string > geometrize::util::split	(	const std::string &	s,
		char	delimiter
	)

split Splits a given string into a vector of tokens using the given delimiter.

Parameters

s	The string to split.
delimiter	The delimiter to split on.

Returns: A vector containing the split string.

 {
     std::vector<std::string> elements;
     split(s, delimiter, std::back_inserter(elements));
     return elements;
 }

Here is the caller graph for this function:

bool geometrize::util::stringBeginsWith	(	const std::string &	str,
		const std::string &	prefix
	)

stringBeginsWith Checks if a string begins with the given prefix.

Parameters

str	The string to check.
prefix	The prefix to check for.

Returns: True if the string begins with the given prefix, false otherwise.

 {
     return str.size() >= prefix.size() && std::equal(prefix.begin(), prefix.end(), str.begin());
 }

Here is the caller graph for this function:

bool geometrize::util::stringEndsWith	(	const std::string &	str,
		const std::string &	suffix
	)

stringEndsWith Checks if a string ends with the given suffix.

Parameters

str	The string to check.
suffix	The suffix ending to check for.

Returns: True if the string ends with the given suffix, false otherwise.

 {
     return str.size() >= suffix.size() && str.compare(str.size() - suffix.size(), suffix.size(), suffix) == 0;
 }

Here is the caller graph for this function:

bool geometrize::util::writeStringToFile	(	const std::string &	str,
		const std::string &	path
	)

writeStringToFile Writes the string to the file path, attempting to overwrite any existing file at the path.

Parameters

str	The string to write to file.
path	The file path to write to.

Returns: True if the string was successfully written to the file, else false.

 {
     std::ofstream out(path, std::ios::trunc | std::ios::out);
     if(!out.is_open()) {
         return false;
     }
 
     if(out) {
         out << str;
     }
 
     out.close();
 
     if(!out) {
         return false;
     }
 
     return true;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void geometrize::util::writeStringVector	(	const std::vector< std::string > &	vec,
		const std::string &	filePath
	)

writeStringVector Writes the string vector to the given filepath as JSON. Will attempt to overwrite any existing file.

Parameters

text	The vector of strings to write.
filePath	The path of the file to write to.

 {
     if(!geometrize::util::stringEndsWith(filePath, ".json")) {
         assert(0 && "Failed to write string vector, check file extension");
     }
 
     // Create folders up to the path if necessary
     const QFileInfo fileInfo(QString::fromStdString(filePath));
     if(!fileInfo.exists()) {
         const bool createdDir{QDir().mkpath(fileInfo.absolutePath())};
         if(!createdDir) {
             assert(0 && "Failed to create directory for string vector");
             return;
         }
     }
 
     std::ofstream file(filePath);
     cereal::JSONOutputArchive archive(file);
     archive(cereal::make_nvp("stringVector", vec));
 }

Here is the call graph for this function:

Here is the caller graph for this function:

Functions

Function Documentation