24 #include "libmesh/utility.h" 25 #include "libmesh/elem.h" 53 #include <sys/ioctl.h> 77 std::string path =
".";
78 for (
int i = 0; i < 5; i++)
80 auto testroot =
pathjoin(path,
"testroot");
91 std::istringstream ss(input);
93 if (ss >> real_value && ss.eof())
100 const std::string & dir_name,
101 const std::string & extra_error_msg)
106 std::string installed_path =
109 auto test_root =
pathjoin(installed_path,
"testroot");
111 mooseError(
"Couldn't locate any installed inputs to copy in path: ",
117 return installed_path;
128 auto docfile =
pathjoin(installed_path,
"css",
"moose.css");
130 return installed_path;
137 return "https://mooseframework.inl.gov/" + path;
141 replaceAll(std::string str,
const std::string & from,
const std::string & to)
143 size_t start_pos = 0;
144 while ((start_pos = str.find(from, start_pos)) != std::string::npos)
146 str.replace(start_pos, from.length(), to);
147 start_pos += to.length();
155 auto slash_pos = orig.find_last_of(
"/");
156 auto path = orig.substr(0, slash_pos);
157 auto file = orig.substr(slash_pos + 1);
158 if (file !=
"LATEST")
163 if (converted.empty())
164 mooseError(
"Unable to find suitable recovery file!");
176 auto s1len = s1.size();
177 auto s2len = s2.size();
179 auto column_start = (decltype(s1len))1;
181 auto column =
new decltype(s1len)[s1len + 1];
182 std::iota(column + column_start, column + s1len + 1, column_start);
184 for (
auto x = column_start; x <= s2len; x++)
187 auto last_diagonal = x - column_start;
188 for (
auto y = column_start; y <= s1len; y++)
190 auto old_diagonal = column[y];
191 auto possibilities = {
192 column[y] + 1, column[y - 1] + 1, last_diagonal + (s1[y - 1] == s2[x - 1] ? 0 : 1)};
193 column[y] =
std::min(possibilities);
194 last_diagonal = old_diagonal;
197 auto result = column[s1len];
205 std::map<char, std::string> escapes;
206 escapes[
'\a'] =
"\\a";
207 escapes[
'\b'] =
"\\b";
208 escapes[
'\f'] =
"\\f";
209 escapes[
'\n'] =
"\\n";
210 escapes[
'\t'] =
"\\t";
211 escapes[
'\v'] =
"\\v";
212 escapes[
'\r'] =
"\\r";
214 for (
const auto & it : escapes)
215 for (
size_t pos = 0; (pos = str.find(it.first, pos)) != std::string::npos;
216 pos += it.second.size())
217 str.replace(pos, 1, it.second);
223 return std::regex_replace(input, std::regex(
"^\\s+|\\s+$|\\s+(?=\\s)"),
"");
228 const std::string & string_to_find,
229 const std::string & delims)
231 std::vector<std::string> elements;
232 tokenize(expression, elements, 0, delims);
234 std::vector<std::string>::iterator found_it =
235 std::find(elements.begin(), elements.end(), string_to_find);
236 if (found_it != elements.end())
246 return (stat(path.c_str(), &buffer) == 0);
251 bool check_line_endings,
252 bool throw_on_unreadable,
253 bool check_for_git_lfs_pointer)
255 std::ifstream in(filename.c_str(), std::ifstream::in);
258 if (throw_on_unreadable)
260 (std::string(
"Unable to open file \"") + filename +
261 std::string(
"\". Check to make sure that it exists and that you have read permission."))
267 if (check_line_endings)
269 std::istream_iterator<char> iter(in);
270 std::istream_iterator<char> eos;
274 mooseError(filename +
" contains Windows(DOS) line endings which are not supported.");
278 mooseError(filename +
" appears to be a Git-LFS pointer. Make sure you have \"git-lfs\" " 279 "installed so that you may pull this file.");
288 mooseAssert(file.is_open(),
"Passed in file handle is not open");
295 std::getline(file, line);
296 if (line.find(
"version https://") != std::string::npos)
305 std::ofstream
out(filename.c_str(), std::ios_base::app);
308 if (throw_on_unwritable)
310 (std::string(
"Unable to open file \"") + filename +
311 std::string(
"\". Check to make sure that it exists and that you have write permission."))
328 Moose::out <<
"Waiting For Other Processors To Finish" << std::endl;
329 if (comm.
rank() == 0)
333 Moose::out <<
"Jobs complete: 1/" << comm.
size() << (1 == comm.
size() ?
"\n" :
"\r")
335 for (
unsigned int i = 2; i <= comm.
size(); ++i)
337 comm.
receive(MPI_ANY_SOURCE, secondary_processor_id);
339 Moose::out <<
"Jobs complete: " << i <<
"/" << comm.
size()
340 << (i == comm.
size() ?
"\n" :
"\r") << std::flush;
345 secondary_processor_id = comm.
rank();
346 comm.
send(0, secondary_processor_id);
363 mooseWarning(
"Entering serial execution block (use only for debugging)");
378 if (comm.
rank() == 0 && warn)
379 mooseWarning(
"Leaving serial execution block (use only for debugging)");
383 hasExtension(
const std::string & filename, std::string ext,
bool strip_exodus_ext)
386 std::string file_ext;
387 if (strip_exodus_ext)
390 ".*\\.([^\\.]*?)(?:-s\\d+)?\\s*$");
391 re.FullMatch(filename, &file_ext);
395 pcrecpp::RE re(
".*\\.([^\\.]*?)\\s*$");
396 re.FullMatch(filename, &file_ext);
409 std::string file_ext =
"";
413 const std::string stripped_filename = splitFileName<std::string>(filename).second;
414 auto pos = rfind ? stripped_filename.rfind(
".") : stripped_filename.find(
".");
415 if (pos != std::string::npos)
416 file_ext += stripped_filename.substr(pos + 1, std::string::npos);
426 const bool offset = (ext.size() != 0);
428 return s.substr(0, s.size() - ext.size() - offset);
438 constexpr
unsigned int BUF_SIZE = 1024;
439 char buffer[BUF_SIZE];
441 return getcwd(buffer, BUF_SIZE) !=
nullptr ? buffer :
"";
445 makedirs(
const std::string & dir_name,
bool throw_on_failure)
448 std::vector<std::string> split_dir_names;
451 auto n = split_dir_names.size();
458 if (split_dir_names[i] ==
".")
460 for (
auto j = i + 1; j < n; ++j)
461 split_dir_names[j - 1] = split_dir_names[j];
464 else if (i > 0 && split_dir_names[i] ==
".." && split_dir_names[i - 1] !=
"..")
466 for (
auto j = i + 1; j < n; ++j)
467 split_dir_names[j - 2] = split_dir_names[j];
477 split_dir_names.resize(n);
480 std::string cur_dir = dir_name[0] ==
'/' ?
"" :
".";
481 for (
auto & dir : split_dir_names)
483 cur_dir +=
"/" + dir;
487 auto code = Utility::mkdir(cur_dir.c_str());
490 std::string msg =
"Failed creating directory " + dir_name;
491 if (throw_on_failure)
492 throw std::invalid_argument(msg);
501 removedirs(
const std::string & dir_name,
bool throw_on_failure)
504 std::vector<std::string> split_dir_names;
507 auto n = split_dir_names.size();
514 if (split_dir_names[i] ==
".")
516 for (
auto j = i + 1; j < n; ++j)
517 split_dir_names[j - 1] = split_dir_names[j];
520 else if (i > 0 && split_dir_names[i] ==
".." && split_dir_names[i - 1] !=
"..")
522 for (
auto j = i + 1; j < n; ++j)
523 split_dir_names[j - 2] = split_dir_names[j];
533 split_dir_names.resize(n);
536 std::string base_dir = dir_name[0] ==
'/' ?
"" :
".";
537 for (i = n; i > 0; --i)
539 std::string cur_dir = base_dir;
541 for (j = 0; j < i; ++j)
542 cur_dir +=
"/" + split_dir_names[j];
547 auto code = rmdir(cur_dir.c_str());
550 std::string msg =
"Failed removing directory " + dir_name;
551 if (throw_on_failure)
552 throw std::invalid_argument(msg);
566 std::string replaced = camel_case_name;
568 pcrecpp::RE(
"(?!^)(?<![A-Z_])([A-Z]+)").GlobalReplace(
"_\\1", &replaced);
571 std::transform(replaced.begin(), replaced.end(), replaced.begin(), ::tolower);
578 pcrecpp::StringPiece input(underscore_name);
579 pcrecpp::RE re(
"([^_]*)(_|$)");
582 std::string us, not_us;
583 bool make_upper = leading_upper_case;
584 while (re.Consume(&input, ¬_us, &us))
586 if (not_us.length() > 0)
590 result += std::toupper(not_us[0]);
591 if (not_us.length() > 1)
592 result += not_us.substr(1);
610 return name.substr(
name.find_last_of(
'/') != std::string::npos ?
name.find_last_of(
'/') + 1 : 0);
616 return name.substr(0,
name.find_last_of(
'/') != std::string::npos ?
name.find_last_of(
'/') : 0);
629 if (!GetComputerNameEx(ComputerNamePhysicalDnsHostname,
hostname, &dwSize))
643 unsigned short ws_col;
654 char * pps_width = std::getenv(
"MOOSE_PPS_WIDTH");
655 if (pps_width != NULL)
657 std::stringstream ss(pps_width);
667 ioctl(0, TIOCGWINSZ, &w);
688 for (
const auto & elem_it : props)
690 Moose::out <<
"Element " << elem_it.first->id() <<
'\n';
693 for (
const auto & side_it : elem_it.second)
695 Moose::out <<
" Side " << side_it.first <<
'\n';
698 unsigned int cnt = 0;
699 for (
const auto & mat_prop : side_it.second)
703 Moose::out <<
" Property " << cnt <<
'\n';
707 for (
unsigned int qp = 0; qp < mp->size(); ++qp)
708 Moose::out <<
" prop[" << qp <<
"] = " << (*mp)[qp] <<
'\n';
714 Moose::out << std::flush;
720 pcrecpp::RE re(
"(\\33\\[3[0-7]m))", pcrecpp::DOTALL());
721 re.GlobalReplace(std::string(
""), &msg);
727 unsigned int line_width )
729 for (
auto i :
make_range(
int(message.length() / line_width)))
730 message.insert((i + 1) * (line_width + 2) - 2,
"\n");
735 std::string & message,
737 bool indent_first_line,
738 const std::string & post_prefix)
745 std::string colored_message;
746 std::string curr_color = COLOR_DEFAULT;
747 std::string line, color_code;
749 bool ends_in_newline = message.empty() ? true : message.back() ==
'\n';
753 std::istringstream iss(message);
754 for (std::string line; std::getline(iss, line);)
756 const static pcrecpp::RE match_color(
".*(\\33\\[3\\dm)((?!\\33\\[3\\d)[^\n])*");
757 pcrecpp::StringPiece line_piece(line);
758 match_color.FindAndConsume(&line_piece, &color_code);
760 if (!first || indent_first_line)
761 colored_message += color + prefix + post_prefix + curr_color;
763 colored_message += line;
766 if (!iss.eof() || ends_in_newline)
767 colored_message +=
"\n";
769 if (!color_code.empty())
770 curr_color = color_code;
774 message = colored_message;
777 std::list<std::string>
778 listDir(
const std::string path,
bool files_only)
780 std::list<std::string> files;
784 tinydir_open(&dir, path.c_str());
790 tinydir_readfile(&dir, &file);
792 if (!files_only || !file.is_dir)
793 files.push_back(path +
"/" + file.name);
803 std::list<std::string>
804 getFilesInDirs(
const std::list<std::string> & directory_list,
const bool files_only )
806 std::list<std::string> files;
808 for (
const auto & dir_name : directory_list)
809 files.splice(files.end(),
listDir(dir_name, files_only));
820 std::time_t newest_time = 0;
821 std::list<std::string> newest_restart_files;
824 for (
const auto & cp_file : checkpoint_files)
829 stat(cp_file.c_str(), &stats);
831 std::time_t mod_time = stats.st_mtime;
832 if (mod_time > newest_time)
834 newest_restart_files.clear();
835 newest_time = mod_time;
838 if (mod_time == newest_time)
839 newest_restart_files.push_back(cp_file);
844 int max_file_num = -1;
845 std::string max_file;
846 std::string max_prefix;
852 pcrecpp::RE re_file_num(
"(.*?(\\d+))-restart-\\d+.rd$");
855 for (
const auto & res_file : newest_restart_files)
860 std::string file_prefix;
862 re_file_num.FullMatch(res_file, &file_prefix, &file_num);
864 if (file_num > max_file_num)
870 max_file_num = file_num;
872 max_prefix = file_prefix;
877 if (max_file_num == -1)
887 if (search_string ==
"")
892 std::transform(search_string.begin(),
894 search_string.begin(),
895 (
int (*)(
int))std::toupper);
898 if (search_string.find(
"*") == std::string::npos)
899 return search_string ==
name;
902 std::vector<std::string> tokens;
906 for (
unsigned int i = 0; i < tokens.size() && pos != std::string::npos; ++i)
908 pos =
name.find(tokens[i], pos);
910 if (search_string[0] !=
'*' && i == 0 && pos != 0)
914 if (pos != std::string::npos && tokens.size() > 0)
917 size_t last_token_length = tokens.back().length();
918 if (*search_string.rbegin() ==
'*' || pos ==
name.size() - last_token_length)
929 const std::string & pattern,
933 if (p == pattern.size())
934 return c == candidate.size();
936 if (pattern[p] ==
'*')
938 for (; c < candidate.size(); ++c)
944 if (pattern[p] !=
'?' && pattern[p] != candidate[c])
947 return globCompare(candidate, pattern, c + 1, p + 1);
950 template <
typename T>
958 long double double_val;
959 std::stringstream double_ss(str);
960 double_ss >> double_val;
963 bool use_int =
false;
964 std::stringstream int_ss(str);
965 if (!(int_ss >> val).fail() && int_ss.eof())
968 if (double_ss.fail() || !double_ss.eof())
971 std::string(
"Unable to convert '") + str +
"' to type " +
demangle(
typeid(T).
name());
973 if (throw_on_failure)
974 throw std::invalid_argument(msg);
980 if (double_val == static_cast<long double>(static_cast<T>(double_val)))
981 return use_int ? val :
static_cast<T
>(double_val);
985 std::string(
"Unable to convert '") + str +
"' to type " +
demangle(
typeid(T).
name());
987 if (throw_on_failure)
988 throw std::invalid_argument(msg);
997 return convertStringToInt<short int>(str, throw_on_failure);
1004 return convertStringToInt<unsigned short int>(str, throw_on_failure);
1011 return convertStringToInt<int>(str, throw_on_failure);
1018 return convertStringToInt<unsigned int>(str, throw_on_failure);
1025 return convertStringToInt<long int>(str, throw_on_failure);
1032 return convertStringToInt<unsigned long int>(str, throw_on_failure);
1039 return convertStringToInt<long long int>(str, throw_on_failure);
1043 unsigned long long int 1046 return convertStringToInt<unsigned long long int>(str, throw_on_failure);
1050 stringJoin(
const std::vector<std::string> & values,
const std::string & separator)
1052 std::string combined;
1053 for (
const auto &
value : values)
1054 combined +=
value + separator;
1056 combined = combined.substr(0, combined.size() - separator.size());
1061 beginsWith(
const std::string & value,
const std::string & begin_value)
1063 return value.rfind(begin_value, 0) == 0;
1086 auto global_num_local_items = num_items / num_chunks;
1088 num_local_items = global_num_local_items;
1090 auto leftovers = num_items % num_chunks;
1092 if (chunk_id < leftovers)
1095 local_items_begin = num_local_items * chunk_id;
1099 (global_num_local_items + 1) * leftovers + global_num_local_items * (chunk_id - leftovers);
1101 local_items_end = local_items_begin + num_local_items;
1107 auto global_num_local_items = num_items / num_chunks;
1109 auto leftovers = num_items % num_chunks;
1111 auto first_item_past_first_part = leftovers * (global_num_local_items + 1);
1114 if (item_id < first_item_past_first_part)
1115 return item_id / (global_num_local_items + 1);
1118 auto new_item_id = item_id - first_item_past_first_part;
1121 return leftovers + (new_item_id / global_num_local_items);
1125 std::vector<std::string>
1128 std::vector<std::string> output;
1129 std::size_t count = 0;
1130 size_t prev = 0, pos = 0;
1134 output.push_back(str.substr(prev, pos - prev));
1137 }
while (pos != std::string::npos && count < max_count);
1139 if (pos != std::string::npos)
1140 output.push_back(str.substr(prev));
1145 std::vector<std::string>
1148 std::vector<std::string> output;
1149 std::size_t count = 0;
1150 size_t prev = str.length(), pos = str.length();
1154 output.insert(output.begin(), str.substr(pos +
delimiter.length(), prev - pos));
1157 }
while (pos != std::string::npos && pos > 0 && count < max_count);
1159 if (pos != std::string::npos)
1160 output.insert(output.begin(), str.substr(0, pos));
1170 auto err = symlink(target.c_str(), link.c_str());
1172 auto err = CreateSymbolicLink(target.c_str(), link.c_str(), 0);
1175 mooseError(
"Failed to create symbolic link (via 'symlink') from ", target,
" to ", link);
1183 if (lstat(link.c_str(), &sbuf) == 0)
1185 auto err = unlink(link.c_str());
1187 mooseError(
"Failed to remove symbolic link (via 'unlink') to ", link);
1190 auto attr = GetFileAttributesA(link.c_str());
1191 if (attr != INVALID_FILE_ATTRIBUTES)
1193 auto err = _unlink(link.c_str());
1195 mooseError(
"Failed to remove link/file (via '_unlink') to ", link);
1205 if (!stat(filename.c_str(), &buffer))
1206 return buffer.st_size;
1208 HANDLE hFile = CreateFile(filename.c_str(),
1210 FILE_SHARE_READ | FILE_SHARE_WRITE,
1213 FILE_ATTRIBUTE_NORMAL,
1215 if (hFile == INVALID_HANDLE_VALUE)
1219 if (GetFileSizeEx(hFile, &size))
1222 return size.QuadPart;
1233 return std::filesystem::absolute(path);
1250 std::string s = cpp_type;
1252 pcrecpp::RE(
"\\s(?=>)").GlobalReplace(
"", &s);
1253 pcrecpp::RE(
"std::__\\w+::").GlobalReplace(
"std::", &s);
1255 pcrecpp::RE(
"\\s*std::basic_string<char, std::char_traits<char>, std::allocator<char>>\\s*")
1256 .GlobalReplace(
"std::string", &s);
1258 pcrecpp::RE r(
"std::vector<([[:print:]]+),\\s?std::allocator<\\s?\\1\\s?>\\s?>");
1259 r.GlobalReplace(
"std::vector<\\1>", &s);
1261 r.GlobalReplace(
"std::vector<\\1>", &s);
1268 return std::filesystem::weakly_canonical(path).c_str();
1272 startsWith(
const std::string & string1,
const std::string & string2)
1274 if (string2.size() > string1.size())
1276 return string1.compare(0, string2.size(), string2) == 0;
1280 replaceStart(std::string & string1,
const std::string & string2,
const std::string & string3)
1283 "Cannot replace the start because it doesn't match the start string");
1284 string1.replace(0, string2.size(), string3);
1291 str.begin(), str.end(), [](
unsigned char c) {
return !std::isalpha(c) || std::islower(c); });
1298 std::string::size_type n = sub.length();
1299 for (std::string::size_type i =
main.find(sub); i != std::string::npos; i =
main.find(sub))
1306 std::string copy_main =
main;
1307 std::string::size_type n = sub.length();
1308 for (std::string::size_type i = copy_main.find(sub); i != std::string::npos;
1309 i = copy_main.find(sub))
1310 copy_main.erase(i, n);
std::string name(const ElemQuality q)
bool parsesToReal(const std::string &input)
Check if the input string can be parsed into a Real.
std::string docsDir(const std::string &app_name)
Returns the directory of any installed docs/site.
bool globCompare(const std::string &candidate, const std::string &pattern, std::size_t c=0, std::size_t p=0)
A MultiMooseEnum object to hold "execute_on" flags.
void serialEnd(const libMesh::Parallel::Communicator &comm, bool warn=true)
Closes a section of code that is executed in serial rank by rank, and that was opened with a call to ...
void tokenize(const std::string &str, std::vector< T > &elements, unsigned int min_len=1, const std::string &delims="/")
This function will split the passed in string on a set of delimiters appending the substrings to the ...
bool beginsWith(const std::string &value, const std::string &begin_value)
HashMap is an abstraction for dictionary data type, we make it thread-safe by locking inserts...
int stringToInteger(const std::string &input, bool throw_on_failure=false)
Robust string to integer conversion that fails for cases such at "1foo".
void mooseError(Args &&... args)
Emit an error message with the given stringified, concatenated args and terminate the application...
void MaterialPropertyStorageDump(const HashMap< const libMesh::Elem *, HashMap< unsigned int, MaterialProperties >> &props)
Function to dump the contents of MaterialPropertyStorage for debugging purposes.
std::string installedInputsDir(const std::string &app_name, const std::string &dir_name, const std::string &extra_error_msg="")
Returns the directory of any installed inputs or the empty string if none are found.
std::string getExecutablePath()
This function returns the PATH of the running executable.
bool isAllLowercase(const std::string &str)
void mooseWarning(Args &&... args)
Emit a warning message with the given stringified, concatenated args.
bool startsWith(const std::string &string1, const std::string &string2)
std::list< std::string > getFilesInDirs(const std::list< std::string > &directory_list, const bool files_only=true)
Retrieves the names of all of the files contained within the list of directories passed into the rout...
processor_id_type rank() const
void removedirs(const std::string &dir_name, bool throw_on_failure=false)
Recursively remove directories from inner-most when the directories are empty.
void linearPartitionItems(dof_id_type num_items, dof_id_type num_chunks, dof_id_type chunk_id, dof_id_type &num_local_items, dof_id_type &local_items_begin, dof_id_type &local_items_end)
Linearly partition a number of items.
bool checkForGitLFSPointer(std::ifstream &file)
Check if the file is a Git-LFS pointer.
std::string realpath(const std::string &path)
Wrapper around PetscGetRealPath, which is a cross-platform replacement for realpath.
static ExecFlagRegistry & getExecFlagRegistry()
Return Singleton instance.
std::string convertLatestCheckpoint(std::string orig)
Replaces "LATEST" placeholders with the latest checkpoint file name.
std::string mooseDocsURL(const std::string &path)
Returns the URL of a page located on the MOOSE documentation site.
std::string hostname()
Get the hostname the current process is running on.
auto max(const L &left, const R &right)
std::string camelCaseToUnderscore(const std::string &camel_case_name)
Function for converting a camel case name to a name containing underscores.
std::string shortName(const std::string &name)
Function for stripping name after the file / in parser block.
void removeSubstring(std::string &main, const std::string &sub)
find, erase, length algorithm for removing a substring from a string
std::vector< std::string > split(const std::string &str, const std::string &delimiter, std::size_t max_count=std::numeric_limits< std::size_t >::max())
Python like split functions for strings.
ExecFlagEnum getDefaultExecFlagEnum()
Return the default ExecFlagEnum for MOOSE.
T convertStringToInt(const std::string &str, bool throw_on_failure)
std::string getExtension(const std::string &filename, const bool rfind=false)
Gets the extension of the passed file name.
void replaceStart(std::string &string1, const std::string &string2, const std::string &string3)
Replace the starting string string2 of string1 with string3.
processor_id_type size() const
std::vector< std::string > rsplit(const std::string &str, const std::string &delimiter, std::size_t max_count=std::numeric_limits< std::size_t >::max())
uint8_t processor_id_type
Status receive(const unsigned int dest_processor_id, T &buf, const MessageTag &tag=any_tag) const
std::string stripExtension(const std::string &s, const bool rfind=false)
Removes any file extension from the given string s (i.e.
int convert< int >(const std::string &str, bool throw_on_failure)
Real value(unsigned n, unsigned alpha, unsigned beta, Real x)
void indentMessage(const std::string &prefix, std::string &message, const char *color=COLOR_CYAN, bool dont_indent_first_line=true, const std::string &post_prefix=": ")
Indents the supplied message given the prefix and color.
void parallelBarrierNotify(const libMesh::Parallel::Communicator &comm, bool messaging=true)
This function implements a parallel barrier function but writes progress to stdout.
std::string getLatestCheckpointFilePrefix(const std::list< std::string > &checkpoint_files)
Returns the most recent checkpoint prefix (the four numbers at the beginning) If a suitable file isn'...
void serialBegin(const libMesh::Parallel::Communicator &comm, bool warn=true)
This function marks the begin of a section of code that is executed in serial rank by rank...
std::string canonicalPath(const std::string &path)
Gets the canonical path of the given path.
bool checkFileReadable(const std::string &filename, bool check_line_endings=false, bool throw_on_unreadable=true, bool check_for_git_lfs_pointer=true)
Checks to see if a file is readable (exists and permissions)
std::string runTestsExecutable()
Returns the location of either a local repo run_tests script - or an installed test executor script i...
std::size_t fileSize(const std::string &filename)
Check the file size.
unsigned int convert< unsigned int >(const std::string &str, bool throw_on_failure)
std::string underscoreToCamelCase(const std::string &underscore_name, bool leading_upper_case)
Function for converting an underscore name to a camel case name.
bool hasExtension(const std::string &filename, std::string ext, bool strip_exodus_ext=false)
Function tests if the supplied filename as the desired extension.
std::string & removeColor(std::string &msg)
remove ANSI escape sequences for terminal color from msg
std::string demangle(const char *name)
bool checkFileWriteable(const std::string &filename, bool throw_on_unwritable=true)
Check if the file is writable (path exists and permissions)
void addLineBreaks(std::string &message, unsigned int line_width)
int main(int argc, char *argv[])
Initialize, create and run a MooseApp.
void clearSymlink(const std::string &link)
Remove a symbolic link, if the given filename is a link.
long long int convert< long long int >(const std::string &str, bool throw_on_failure)
processor_id_type linearPartitionChunk(dof_id_type num_items, dof_id_type num_chunks, dof_id_type item_id)
Return the chunk_id that is assigned to handle item_id.
void createSymlink(const std::string &target, const std::string &link)
Create a symbolic link, if the link already exists it is replaced.
short int convert< short int >(const std::string &str, bool throw_on_failure)
std::filesystem::path pathjoin(const std::filesystem::path &p)
unsigned long int convert< unsigned long int >(const std::string &str, bool throw_on_failure)
std::string baseName(const std::string &name)
Function for string the information before the final / in a parser block.
DIE A HORRIBLE DEATH HERE typedef LIBMESH_DEFAULT_SCALAR_TYPE Real
bool wildCardMatch(std::string name, std::string search_string)
void send(const unsigned int dest_processor_id, const T &buf, const MessageTag &tag=no_tag) const
IntRange< T > make_range(T beg, T end)
const ExecFlagEnum & getDefaultFlags() const
std::list< std::string > listDir(const std::string path, bool files_only=false)
libMesh::BoundingBox buildBoundingBox(const Point &p1, const Point &p2)
Construct a valid bounding box from 2 arbitrary points.
int levenshteinDist(const std::string &s1, const std::string &s2)
Computes and returns the Levenshtein distance between strings s1 and s2.
std::string getCurrentWorkingDir()
Returns the current working directory as a string.
void makedirs(const std::string &dir_name, bool throw_on_failure=false)
Recursively make directories.
std::string removeExtraWhitespace(const std::string &str)
Removes additional whitespace from a string.
long int convert< long int >(const std::string &str, bool throw_on_failure)
void union_with(const Point &p)
unsigned short int convert< unsigned short int >(const std::string &str, bool throw_on_failure)
bool pathContains(const std::string &expression, const std::string &string_to_find, const std::string &delims="/")
This function tokenizes a path and checks to see if it contains the string to look for...
bool pathExists(const std::string &path)
std::string replaceAll(std::string str, const std::string &from, const std::string &to)
Replaces all occurrences of from in str with to and returns the result.
auto min(const L &left, const R &right)
std::string stringJoin(const std::vector< std::string > &values, const std::string &separator=" ")
Concatenates value into a single string separated by separator.
unsigned long long int convert< unsigned long long int >(const std::string &str, bool throw_on_failure)
void ErrorVector unsigned int
void escape(std::string &str)
This function will escape all of the standard C++ escape characters so that they can be printed...
std::string prettyCppType(const std::string &cpp_type)
std::string findTestRoot()
Searches in the current working directory and then recursively up in each parent directory looking fo...
unsigned short getTermWidth(bool use_environment)
Returns the width of the terminal using sys/ioctl.
static bool isAvailable(const std::filesystem::path &folder_base)