MooseUtils Namespace Reference

Classes
class	Buffer
	Base class for a buffer. More...
class	CircularBuffer
	An optimized circular buffer. More...
class	DelimitedFileReaderTempl
	Utility class for reading delimited data (e.g., CSV data). More...
class	LIFOBuffer
	An optimized LIFO (Last In First Out) buffer. More...
class	SharedPool
	Originally From https://stackoverflow.com/a/27837534/2042320. More...
class	StaticallyAllocatedSet
	Optimized set with static allocation. More...

Typedefs
typedef DelimitedFileReaderTempl< double >	DelimitedFileReader
typedef DelimitedFileReaderTempl< std::string >	DelimitedFileOfStringReader

Functions
std::string	trim (const std::string &str, const std::string &white_space=" \\\)
	Standard scripting language trim function. More...
template<typename T >
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 passed in vector. More...
template<class T >
bool	convert (const std::string &str, T &value, const bool throw_on_failure)
	Takes the string representation of a value and converts it to the value. More...
template<typename T >
bool	tokenizeAndConvert (const std::string &str, std::vector< T > &tokenized_vector, const std::string &delimiter=" \\\)
	tokenizeAndConvert splits a string using delimiter and then converts to type T. More...
std::string	toUpper (std::string name)
	Convert supplied string to upper case. More...
std::string	toLower (std::string name)
	Convert supplied string to lower case. More...
std::string	stringJoin (const std::vector< std::string > &values, const std::string &separator=" ")
	Concatenates value into a single string separated by separator. More...
template<class T , typename... Args>
auto	reset (int, T &obj, Args... args) -> decltype(obj.reset(args...), void())
template<class T , typename... Args>
void	reset (double, T &, Args...)
std::filesystem::path	pathjoin (const std::filesystem::path &p)
std::string	runTestsExecutable ()
std::string	findTestRoot ()
bool	parsesToReal (const std::string &input, Real *parsed_real)
std::string	installedInputsDir (const std::string &app_name, const std::string &dir_name, const std::string &extra_error_msg)
std::string	docsDir (const std::string &app_name)
std::string	mooseDocsURL (const std::string &path)
std::string	replaceAll (std::string str, const std::string &from, const std::string &to)
std::string	convertLatestCheckpoint (std::string orig)
int	levenshteinDist (const std::string &s1, const std::string &s2)
void	escape (std::string &str)
std::string	removeExtraWhitespace (const std::string &input)
bool	pathContains (const std::string &expression, const std::string &string_to_find, const std::string &delims)
bool	pathExists (const std::string &path)
bool	checkFileReadable (const std::string &filename, bool check_line_endings, bool throw_on_unreadable, bool check_for_git_lfs_pointer)
bool	checkForGitLFSPointer (std::ifstream &file)
bool	checkFileWriteable (const std::string &filename, bool throw_on_unwritable)
void	parallelBarrierNotify (const Parallel::Communicator &comm, bool messaging)
void	serialBegin (const libMesh::Parallel::Communicator &comm, bool warn)
void	serialEnd (const libMesh::Parallel::Communicator &comm, bool warn)
bool	hasExtension (const std::string &filename, std::string ext, bool strip_exodus_ext)
std::string	getExtension (const std::string &filename, const bool rfind)
std::string	stripExtension (const std::string &s, const bool rfind)
std::string	getCurrentWorkingDir ()
void	makedirs (const std::string &dir_name, bool throw_on_failure)
void	removedirs (const std::string &dir_name, bool throw_on_failure)
std::string	camelCaseToUnderscore (const std::string &camel_case_name)
std::string	underscoreToCamelCase (const std::string &underscore_name, bool leading_upper_case)
std::string	shortName (const std::string &name)
std::string	baseName (const std::string &name)
std::string	hostname ()
unsigned short	getTermWidth (bool use_environment)
void	MaterialPropertyStorageDump (const HashMap< const libMesh::Elem *, HashMap< unsigned int, MaterialProperties >> &props)
std::string &	removeColor (std::string &msg)
void	addLineBreaks (std::string &message, unsigned int line_width)
void	indentMessage (const std::string &prefix, std::string &message, const char *color, bool indent_first_line, const std::string &post_prefix)
std::list< std::string >	listDir (const std::string path, bool files_only)
std::list< std::string >	getFilesInDirs (const std::list< std::string > &directory_list, const bool files_only)
std::string	getLatestCheckpointFilePrefix (const std::list< std::string > &checkpoint_files)
bool	wildCardMatch (std::string name, std::string search_string)
bool	globCompare (const std::string &candidate, const std::string &pattern, std::size_t c, std::size_t p)
bool	beginsWith (const std::string &value, const std::string &begin_value)
ExecFlagEnum	getDefaultExecFlagEnum ()
int	stringToInteger (const std::string &input, bool throw_on_failure)
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)
processor_id_type	linearPartitionChunk (dof_id_type num_items, dof_id_type num_chunks, dof_id_type item_id)
std::vector< std::string >	split (const std::string &str, const std::string &delimiter, std::size_t max_count)
std::vector< std::string >	rsplit (const std::string &str, const std::string &delimiter, std::size_t max_count)
void	createSymlink (const std::string &target, const std::string &link)
void	clearSymlink (const std::string &link)
std::size_t	fileSize (const std::string &filename)
std::string	realpath (const std::string &path)
BoundingBox	buildBoundingBox (const Point &p1, const Point &p2)
std::string	prettyCppType (const std::string &cpp_type)
std::string	canonicalPath (const std::string &path)
bool	startsWith (const std::string &string1, const std::string &string2)
void	replaceStart (std::string &string1, const std::string &string2, const std::string &string3)
bool	isAllLowercase (const std::string &str)
template<typename T >
void	swap (std::vector< T > &data, const std::size_t idx0, const std::size_t idx1, const libMesh::Parallel::Communicator &comm)
	Swap function for serial or distributed vector of data. More...
template<typename T >
void	swap (std::vector< T > &data, const std::size_t idx0, const std::size_t idx1, const libMesh::Parallel::Communicator *comm_ptr=nullptr)
template<typename T >
void	shuffle (std::vector< T > &data, MooseRandom &generator, const std::size_t seed_index=0)
	Shuffle function for serial or distributed vector of data that shuffles in place. More...
template<typename T >
void	shuffle (std::vector< T > &data, MooseRandom &generator, const libMesh::Parallel::Communicator &comm)
template<typename T >
void	shuffle (std::vector< T > &data, MooseRandom &generator, const std::size_t seed_index, const libMesh::Parallel::Communicator &comm)
template<typename T >
void	shuffle (std::vector< T > &data, MooseRandom &generator, const std::size_t seed_index, const libMesh::Parallel::Communicator *comm_ptr)
template<typename T >
std::vector< T >	resample (const std::vector< T > &data, MooseRandom &generator, const std::size_t seed_index=0)
	Randomly resample a vector of data, allowing a value to be repeated. More...
template<typename T >
std::vector< T >	resample (const std::vector< T > &data, MooseRandom &generator, const libMesh::Parallel::Communicator &comm)
template<typename T >
std::vector< T >	resample (const std::vector< T > &data, MooseRandom &generator, const std::size_t seed_index, const libMesh::Parallel::Communicator &comm)
template<typename T >
std::vector< T >	resample (const std::vector< T > &data, MooseRandom &generator, const std::size_t seed_index, const libMesh::Parallel::Communicator *comm_ptr)
template<typename T , typename ActionFunctor >
void	resampleWithFunctor (const std::vector< T > &data, const ActionFunctor &functor, MooseRandom &generator, const std::size_t seed_index=0)
	Randomly resample a vector of data and apply a functor, allowing a value to be repeated. More...
template<typename T , typename ActionFunctor >
void	resampleWithFunctor (const std::vector< T > &data, const ActionFunctor &functor, MooseRandom &generator, const libMesh::Parallel::Communicator &comm)
template<typename T , typename ActionFunctor >
void	resampleWithFunctor (const std::vector< T > &data, const ActionFunctor &functor, MooseRandom &generator, const std::size_t seed_index, const libMesh::Parallel::Communicator &comm)
template<typename T , typename ActionFunctor >
void	resampleWithFunctor (const std::vector< T > &data, const ActionFunctor &functor, MooseRandom &generator, const std::size_t seed_index, const libMesh::Parallel::Communicator *comm_ptr)

Typedef Documentation

DelimitedFileOfStringReader

typedef DelimitedFileReaderTempl<std::string> MooseUtils::DelimitedFileOfStringReader

Definition at line 201 of file DelimitedFileReader.h.

DelimitedFileReader

typedef DelimitedFileReaderTempl<double> MooseUtils::DelimitedFileReader

Definition at line 200 of file DelimitedFileReader.h.

Function Documentation

addLineBreaks()

void MooseUtils::addLineBreaks	(	std::string &	message,
		unsigned int	line_width
	)

Definition at line 730 of file MooseUtils.C.

{
  for (auto i : make_range(int(message.length() / line_width)))
    message.insert((i + 1) * (line_width + 2) - 2, "\n");
}

baseName()

std::string MooseUtils::baseName

(

const std::string &

name

)

Definition at line 618 of file MooseUtils.C.

Referenced by Moose::Builder::walkRaw().

{
  return name.substr(0, name.find_last_of('/') != std::string::npos ? name.find_last_of('/') : 0);
}

beginsWith()

bool MooseUtils::beginsWith	(	const std::string &	value,
		const std::string &	begin_value
	)

Definition at line 955 of file MooseUtils.C.

Referenced by CommandLine::initSubAppCommandLine(), CommandLine::parse(), and CommandLine::setCommandLineParam().

{
  return value.rfind(begin_value, 0) == 0;
}

buildBoundingBox()

BoundingBox MooseUtils::buildBoundingBox	(	const Point &	p1,
		const Point &	p2
	)

Definition at line 1131 of file MooseUtils.C.

Referenced by PropertyReadFile::PropertyReadFile().

{
  BoundingBox bb;
  bb.union_with(p1);
  bb.union_with(p2);
  return bb;
}

camelCaseToUnderscore()

std::string MooseUtils::camelCaseToUnderscore

(

const std::string &

camel_case_name

)

Definition at line 568 of file MooseUtils.C.

Referenced by MooseApp::appNameToLibName().

{
  std::string replaced = camel_case_name;
  // Put underscores in front of each contiguous set of capital letters
  pcrecpp::RE("(?!^)(?<![A-Z_])([A-Z]+)").GlobalReplace("_\\1", &replaced);

  // Convert all capital letters to lower case
  std::transform(replaced.begin(), replaced.end(), replaced.begin(), ::tolower);
  return replaced;
}

canonicalPath()

std::string MooseUtils::canonicalPath

(

const std::string &

path

)

Definition at line 1173 of file MooseUtils.C.

Referenced by Registry::determineDataFilePath(), and Moose::DataFileUtils::getPath().

{
  return std::filesystem::weakly_canonical(path).c_str();
}

checkFileReadable()

bool MooseUtils::checkFileReadable	(	const std::string &	filename,
		bool	check_line_endings,
		bool	throw_on_unreadable,
		bool	check_for_git_lfs_pointer
	)

Definition at line 254 of file MooseUtils.C.

Referenced by MooseServer::addResourcesForDocument(), FileMesh::buildMesh(), Registry::determineDataFilePath(), docsDir(), MooseApp::dynamicRegistration(), ExodusFileTimes::ExodusFileTimes(), findTestRoot(), MooseServer::gatherDocumentDefinitionLocations(), FileMeshGenerator::generate(), Moose::DataFileUtils::getPath(), ExodusTimeSequenceStepper::init(), installedInputsDir(), RestartableDataReader::isAvailable(), ADFParser::JITCompile(), MooseApp::loadLibraryAndDependencies(), Exodus::output(), Parser::parse(), MooseUtils::DelimitedFileReaderTempl< T >::read(), JSONFileReader::read(), MultiApp::readCommandLineArguments(), SolutionUserObjectBase::readXda(), MooseApp::run(), runTestsExecutable(), and ValueCache< T >::ValueCache().

{
  std::ifstream in(filename.c_str(), std::ifstream::in);
  if (in.fail())
  {
    if (throw_on_unreadable)
      mooseError(
          (std::string("Unable to open file \"") + filename +
           std::string("\". Check to make sure that it exists and that you have read permission."))
              .c_str());
    else
      return false;
  }

  if (check_line_endings)
  {
    std::istream_iterator<char> iter(in);
    std::istream_iterator<char> eos;
    in >> std::noskipws;
    while (iter != eos)
      if (*iter++ == '\r')
        mooseError(filename + " contains Windows(DOS) line endings which are not supported.");
  }

  if (check_for_git_lfs_pointer && checkForGitLFSPointer(in))
    mooseError(filename + " appears to be a Git-LFS pointer. Make sure you have \"git-lfs\" "
                          "installed so that you may pull this file.");
  in.close();

  return true;
}

checkFileWriteable()

bool MooseUtils::checkFileWriteable	(	const std::string &	filename,
		bool	throw_on_unwritable
	)

Definition at line 307 of file MooseUtils.C.

Referenced by PNGOutput::makePNG().

{
  std::ofstream out(filename.c_str(), std::ios_base::app);
  if (out.fail())
  {
    if (throw_on_unwritable)
      mooseError(
          (std::string("Unable to open file \"") + filename +
           std::string("\". Check to make sure that it exists and that you have write permission."))
              .c_str());
    else
      return false;
  }

  out.close();

  return true;
}

checkForGitLFSPointer()

bool MooseUtils::checkForGitLFSPointer

(

std::ifstream &

file

)

Definition at line 290 of file MooseUtils.C.

Referenced by checkFileReadable().

{
  mooseAssert(file.is_open(), "Passed in file handle is not open");

  std::string line;

  // git-lfs pointer files contain several name value pairs. The specification states that the
  // first name/value pair must be "version {url}". We'll do a simplified check for that.
  file.seekg(0);
  std::getline(file, line);
  if (line.find("version https://") != std::string::npos)
    return true;
  else
    return false;
}

clearSymlink()

void MooseUtils::clearSymlink

(

const std::string &

link

)

Definition at line 1073 of file MooseUtils.C.

Referenced by createSymlink(), and CSV::initialSetup().

{
#ifndef __WIN32__
  struct stat sbuf;
  if (lstat(link.c_str(), &sbuf) == 0)
  {
    auto err = unlink(link.c_str());
    if (err != 0)
      mooseError("Failed to remove symbolic link (via 'unlink') to ", link);
  }
#else
  auto attr = GetFileAttributesA(link.c_str());
  if (attr != INVALID_FILE_ATTRIBUTES)
  {
    auto err = _unlink(link.c_str());
    if (err != 0)
      mooseError("Failed to remove link/file (via '_unlink') to ", link);
  }
#endif
}

convert()

template<class T >

bool MooseUtils::convert	(	const std::string &	str,
		T &	value,
		const bool	throw_on_failure
	)

Takes the string representation of a value and converts it to the value.

For standard numeric types, this gets around the deficiencies in the STL stoi and stod methods where they might successfully convert part of a string to a number when we'd instead prefer to get a failure.

For string and string-derived types, this does a direct copy and does not utilize a stream.

For all other types, this uses the stringstream >> operator to fill the value.

Parameters

str	The string to convert from
value	The typed value to fill
throw_on_failure	If true, throw a std::invalid_argument on failure

Returns

Whether or not the conversion succeeded

Definition at line 96 of file MooseStringUtils.h.

Referenced by MooseServer::getDocumentSymbolKind().

{
  // Special case for numeric values, also handling range checking
  if constexpr (std::is_same_v<short int, T> || std::is_same_v<unsigned short int, T> ||
                std::is_same_v<int, T> || std::is_same_v<unsigned int, T> ||
                std::is_same_v<long int, T> || std::is_same_v<unsigned long int, T> ||
                std::is_same_v<long long int, T> || std::is_same_v<unsigned long long int, T>)
  {
    // Try read a double and try to cast it to an int
    long double double_val;
    std::stringstream double_ss(str);
    double_ss >> double_val;

    if (!double_ss.fail() && double_ss.eof())
    {
      // on arm64 the long double does not have sufficient precision
      std::stringstream int_ss(str);
      const bool use_int = !(int_ss >> value).fail() && int_ss.eof();

      // Check to see if it's an integer and thus within range of an integer
      if (double_val == static_cast<long double>(static_cast<T>(double_val)))
      {
        if (!use_int)
          value = static_cast<T>(double_val);
        return true;
      }
    }
  }
  // Non numeric values
  else
  {
    // string or derived string: direct copy
    if constexpr (std::is_base_of_v<std::string, T>)
    {
      value = str;
      return true;
    }
    // non-string or numeric, use stringstream >>
    else
    {
      std::stringstream ss(trim(str));
      if (!(ss >> value).fail() && ss.eof())
        return true;
    }
  }

  if (throw_on_failure)
  {
    std::string error = "Unable to convert '" + str + "' to type ";
#ifdef MOOSESTRINGUTILS_NO_LIBMESH
    error += typeid(T).name();
#else
    error += libMesh::demangle(typeid(T).name());
#endif
    throw std::invalid_argument(error);
  }

  return false;
}

convertLatestCheckpoint()

std::string MooseUtils::convertLatestCheckpoint

(

std::string

orig

)

Definition at line 157 of file MooseUtils.C.

Referenced by SetupRecoverFileBaseAction::act(), FileMeshGenerator::deduceCheckpointPath(), and FEProblemBase::FEProblemBase().

{
  auto slash_pos = orig.find_last_of("/");
  auto path = orig.substr(0, slash_pos);
  auto file = orig.substr(slash_pos + 1);
  if (file != "LATEST")
    return orig;

  auto converted = MooseUtils::getLatestCheckpointFilePrefix(MooseUtils::listDir(path));

  if (converted.empty())
    mooseError("Unable to find suitable recovery file!");

  return converted;
}

createSymlink()

void MooseUtils::createSymlink	(	const std::string &	target,
		const std::string &	link
	)

Definition at line 1060 of file MooseUtils.C.

Referenced by CSV::output().

{
  clearSymlink(link);
#ifndef __WIN32__
  auto err = symlink(target.c_str(), link.c_str());
#else
  auto err = CreateSymbolicLink(target.c_str(), link.c_str(), 0);
#endif
  if (err)
    mooseError("Failed to create symbolic link (via 'symlink') from ", target, " to ", link);
}

docsDir()

std::string MooseUtils::docsDir

(

const std::string &

app_name

)

Definition at line 125 of file MooseUtils.C.

Referenced by MooseApp::run().

{
  // See moose.mk for a detailed explanation of the assumed installed application
  // layout. Installed docs are expected to be installed in "share/<app_name>/doc".
  // The binary, which has a defined location will be in "bin", a peer directory to "share".
  std::string installed_path = pathjoin(Moose::getExecutablePath(), "..", "share", app_name, "doc");

  auto docfile = pathjoin(installed_path, "css", "moose.css");
  if (pathExists(docfile) && checkFileReadable(docfile))
    return installed_path;
  return "";
}

escape()

void MooseUtils::escape

(

std::string &

str

)

Definition at line 207 of file MooseUtils.C.

Referenced by MooseServer::addParametersToList(), MooseServer::addValuesToList(), MooseServer::getHoverDisplayText(), YAMLFormatter::printBlockOpen(), InputFileFormatter::printParams(), YAMLFormatter::printParams(), and JsonSyntaxTree::setParams().

{
  std::map<char, std::string> escapes;
  escapes['\a'] = "\\a";
  escapes['\b'] = "\\b";
  escapes['\f'] = "\\f";
  escapes['\n'] = "\\n";
  escapes['\t'] = "\\t";
  escapes['\v'] = "\\v";
  escapes['\r'] = "\\r";

  for (const auto & it : escapes)
    for (size_t pos = 0; (pos = str.find(it.first, pos)) != std::string::npos;
         pos += it.second.size())
      str.replace(pos, 1, it.second);
}

fileSize()

std::size_t MooseUtils::fileSize

(

const std::string &

filename

)

Definition at line 1095 of file MooseUtils.C.

Referenced by Exodus::output().

{
#ifndef __WIN32__
  struct stat buffer;
  if (!stat(filename.c_str(), &buffer))
    return buffer.st_size;
#else
  HANDLE hFile = CreateFile(filename.c_str(),
                            GENERIC_READ,
                            FILE_SHARE_READ | FILE_SHARE_WRITE,
                            NULL,
                            OPEN_EXISTING,
                            FILE_ATTRIBUTE_NORMAL,
                            NULL);
  if (hFile == INVALID_HANDLE_VALUE)
    return 0;

  LARGE_INTEGER size;
  if (GetFileSizeEx(hFile, &size))
  {
    CloseHandle(hFile);
    return size.QuadPart;
  }

  CloseHandle(hFile);
#endif
  return 0;
}

findTestRoot()

std::string MooseUtils::findTestRoot

(

)

Definition at line 75 of file MooseUtils.C.

Referenced by MooseApp::runInputs().

{
  std::string path = ".";
  for (int i = 0; i < 5; i++)
  {
    auto testroot = pathjoin(path, "testroot");
    if (pathExists(testroot) && checkFileReadable(testroot))
      return testroot;
    path += "/..";
  }
  return "";
}

getCurrentWorkingDir()

std::string MooseUtils::getCurrentWorkingDir

(

)

Definition at line 436 of file MooseUtils.C.

Referenced by MooseApp::runInputs().

{
  // Note: At the time of creating this method, our minimum compiler still
  // does not support <filesystem>. Additionally, the inclusion of that header
  // requires an additional library to be linked so for now, we'll just
  // use the Unix standard library to get us the cwd().
  constexpr unsigned int BUF_SIZE = 1024;
  char buffer[BUF_SIZE];

  return getcwd(buffer, BUF_SIZE) != nullptr ? buffer : "";
}

getDefaultExecFlagEnum()

ExecFlagEnum MooseUtils::getDefaultExecFlagEnum

(

)

Definition at line 961 of file MooseUtils.C.

Referenced by AddNodalNormalsAction::act(), AdvancedOutput::addValidParams(), Output::getDefaultExecFlagEnum(), Control::getExecuteOptions(), OutputOnWarehouse::OutputOnWarehouse(), SetupDebugAction::validParams(), NEML2BatchIndexGenerator::validParams(), NEML2Assembly::validParams(), MOOSEQuantityToNEML2< T, state >::validParams(), NEML2ModelExecutor::validParams(), SetupInterface::validParams(), and NEML2FEInterpolation::validParams().

{
  return moose::internal::ExecFlagRegistry::getExecFlagRegistry().getDefaultFlags();
}

getExtension()

std::string MooseUtils::getExtension	(	const std::string &	filename,
		const bool	rfind
	)

Definition at line 411 of file MooseUtils.C.

Referenced by SplitMeshAction::act(), CommonOutputAction::act(), SetupMeshAction::modifyParamsForUseSplit(), and stripExtension().

{
  std::string file_ext = "";
  if (filename != "")
  {
    // The next line splits filename at the last "/" and gives the file name after "/"
    const std::string stripped_filename = splitFileName<std::string>(filename).second;
    auto pos = rfind ? stripped_filename.rfind(".") : stripped_filename.find(".");
    if (pos != std::string::npos)
      file_ext += stripped_filename.substr(pos + 1, std::string::npos);
  }

  return file_ext;
}

getFilesInDirs()

std::list<std::string> MooseUtils::getFilesInDirs	(	const std::list< std::string > &	directory_list,
		const bool	files_only
	)

Definition at line 808 of file MooseUtils.C.

Referenced by MooseApp::getCheckpointFiles().

{
  std::list<std::string> files;

  for (const auto & dir_name : directory_list)
    files.splice(files.end(), listDir(dir_name, files_only));

  return files;
}

getLatestCheckpointFilePrefix()

std::string MooseUtils::getLatestCheckpointFilePrefix

(

const std::list< std::string > &

checkpoint_files

)

Definition at line 819 of file MooseUtils.C.

Referenced by convertLatestCheckpoint(), and MooseApp::setRestartRecoverFileBase().

{
  // Create storage for newest restart files
  // Note that these might have the same modification time if the simulation was fast.
  // In that case we're going to save all of the "newest" files and sort it out momentarily
  std::time_t newest_time = 0;
  std::list<std::string> newest_restart_files;

  // Loop through all possible files and store the newest
  for (const auto & cp_file : checkpoint_files)
  {
    if (MooseUtils::hasExtension(cp_file, "rd"))
    {
      struct stat stats;
      stat(cp_file.c_str(), &stats);

      std::time_t mod_time = stats.st_mtime;
      if (mod_time > newest_time)
      {
        newest_restart_files.clear(); // If the modification time is greater, clear the list
        newest_time = mod_time;
      }

      if (mod_time == newest_time)
        newest_restart_files.push_back(cp_file);
    }
  }

  // Loop through all of the newest files according the number in the file name
  int max_file_num = -1;
  std::string max_file;
  std::string max_prefix;

  // Pull out the path including the number and the number itself
  // This takes something_blah_out_cp/0024-restart-1.rd
  // and returns "something_blah_out_cp/0024" as the "prefix"
  // and then "24" as the number itself
  pcrecpp::RE re_file_num("(.*?(\\d+))-restart-\\d+.rd$");

  // Now, out of the newest files find the one with the largest number in it
  for (const auto & res_file : newest_restart_files)
  {
    int file_num = 0;

    // All of the file up to and including the digits
    std::string file_prefix;

    re_file_num.FullMatch(res_file, &file_prefix, &file_num);

    if (file_num > max_file_num)
    {
      // Need both the header and the data
      if (!RestartableDataReader::isAvailable(res_file))
        continue;

      max_file_num = file_num;
      max_file = res_file;
      max_prefix = file_prefix;
    }
  }

  // Error if nothing was located
  if (max_file_num == -1)
    mooseError("No checkpoint file found!");

  return max_prefix;
}

getTermWidth()

unsigned short MooseUtils::getTermWidth

(

bool

use_environment

)

Initialize the value we intend to populate just in case the system call fails

Definition at line 640 of file MooseUtils.C.

Referenced by FormattedTable::printTable().

{
#ifndef __WIN32__
  struct winsize w;
#else
  struct
  {
    unsigned short ws_col;
  } w;
#endif

  w.ws_col = std::numeric_limits<unsigned short>::max();

  if (use_environment)
  {
    char * pps_width = std::getenv("MOOSE_PPS_WIDTH");
    if (pps_width != NULL)
    {
      std::stringstream ss(pps_width);
      ss >> w.ws_col;
    }
  }
  // Default to AUTO if no environment variable was set
  if (w.ws_col == std::numeric_limits<unsigned short>::max())
  {
#ifndef __WIN32__
    try
    {
      ioctl(0, TIOCGWINSZ, &w);
    }
    catch (...)
#endif
    {
    }
  }

  // Something bad happened, make sure we have a sane value
  // 132 seems good for medium sized screens, and is available as a GNOME preset
  if (w.ws_col == std::numeric_limits<unsigned short>::max())
    w.ws_col = 132;

  return w.ws_col;
}

globCompare()

bool MooseUtils::globCompare	(	const std::string &	candidate,
		const std::string &	pattern,
		std::size_t	c,
		std::size_t	p
	)

Definition at line 932 of file MooseUtils.C.

Referenced by RestartableDataReporter::execute(), and ReferenceResidualConvergence::initialSetup().

{
  if (p == pattern.size())
    return c == candidate.size();

  if (pattern[p] == '*')
  {
    for (; c < candidate.size(); ++c)
      if (globCompare(candidate, pattern, c, p + 1))
        return true;
    return globCompare(candidate, pattern, c, p + 1);
  }

  if (pattern[p] != '?' && pattern[p] != candidate[c])
    return false;

  return globCompare(candidate, pattern, c + 1, p + 1);
}

hasExtension()

bool MooseUtils::hasExtension	(	const std::string &	filename,
		std::string	ext,
		bool	strip_exodus_ext
	)

Definition at line 387 of file MooseUtils.C.

Referenced by FileMesh::FileMesh(), FileRangeBuilder::FileRangeBuilder(), getLatestCheckpointFilePrefix(), and SolutionUserObjectBase::initialSetup().

{
  // Extract the extension, w/o the '.'
  std::string file_ext;
  if (strip_exodus_ext)
  {
    pcrecpp::RE re(
        ".*\\.([^\\.]*?)(?:-s\\d+)?\\s*$"); // capture the complete extension, ignoring -s*
    re.FullMatch(filename, &file_ext);
  }
  else
  {
    pcrecpp::RE re(".*\\.([^\\.]*?)\\s*$"); // capture the complete extension
    re.FullMatch(filename, &file_ext);
  }

  // Perform the comparision
  if (file_ext == ext)
    return true;
  else
    return false;
}

hostname()

std::string MooseUtils::hostname

(

)

Definition at line 624 of file MooseUtils.C.

{
  char hostname[1024];
  hostname[1023] = '\0';
#ifndef __WIN32__
  if (gethostname(hostname, 1023))
    mooseError("Failed to retrieve hostname!");
#else
  DWORD dwSize = sizeof(hostname);
  if (!GetComputerNameEx(ComputerNamePhysicalDnsHostname, hostname, &dwSize))
    mooseError("Failed to retrieve hostname!");
#endif
  return hostname;
}

indentMessage()

void MooseUtils::indentMessage	(	const std::string &	prefix,
		std::string &	message,
		const char *	color,
		bool	indent_first_line,
		const std::string &	post_prefix
	)

Definition at line 738 of file MooseUtils.C.

Referenced by DefaultNonlinearConvergence::checkConvergence(), ConsoleUtils::formatString(), OutputWarehouse::mooseConsole(), moose::internal::mooseErrorRaw(), and Console::write().

{
  // First we need to see if the message we need to indent (with color) also contains color codes
  // that span lines.
  // The code matches all of the XTERM constants (see XTermConstants.h). If it does, then we'll work
  // on formatting
  // each colored multiline chunk one at a time with the right codes.
  std::string colored_message;
  std::string curr_color = COLOR_DEFAULT; // tracks last color code before newline
  std::string line, color_code;

  bool ends_in_newline = message.empty() ? true : message.back() == '\n';

  bool first = true;

  std::istringstream iss(message);
  for (std::string line; std::getline(iss, line);) // loop over each line
  {
    const static pcrecpp::RE match_color(".*(\\33\\[3\\dm)((?!\\33\\[3\\d)[^\n])*");
    pcrecpp::StringPiece line_piece(line);
    match_color.FindAndConsume(&line_piece, &color_code);

    if (!first || indent_first_line)
      colored_message += color + prefix + post_prefix + curr_color;

    colored_message += line;

    // Only add a newline to the last line if it had one to begin with!
    if (!iss.eof() || ends_in_newline)
      colored_message += "\n";

    if (!color_code.empty())
      curr_color = color_code; // remember last color of this line

    first = false;
  }
  message = colored_message;
}

installedInputsDir()

std::string MooseUtils::installedInputsDir	(	const std::string &	app_name,
		const std::string &	dir_name,
		const std::string &	extra_error_msg
	)

Definition at line 103 of file MooseUtils.C.

Referenced by MooseApp::copyInputs().

{
  // See moose.mk for a detailed explanation of the assumed installed application
  // layout. Installed inputs are expected to be installed in "share/<app_name>/<folder>".
  // The binary, which has a defined location will be in "bin", a peer directory to "share".
  std::string installed_path =
      pathjoin(Moose::getExecutablePath(), "..", "share", app_name, dir_name);

  auto test_root = pathjoin(installed_path, "testroot");
  if (!pathExists(installed_path))
    mooseError("Couldn't locate any installed inputs to copy in path: ",
               installed_path,
               '\n',
               extra_error_msg);

  checkFileReadable(test_root);
  return installed_path;
}

isAllLowercase()

bool MooseUtils::isAllLowercase

(

const std::string &

str

)

Definition at line 1195 of file MooseUtils.C.

{
  return std::all_of(
      str.begin(), str.end(), [](unsigned char c) { return !std::isalpha(c) || std::islower(c); });
}

levenshteinDist()

int MooseUtils::levenshteinDist	(	const std::string &	s1,
		const std::string &	s2
	)

Definition at line 176 of file MooseUtils.C.

Referenced by Moose::findSimilar().

{
  // To change the type this function manipulates and returns, change
  // the return type and the types of the two variables below.
  auto s1len = s1.size();
  auto s2len = s2.size();

  auto column_start = (decltype(s1len))1;

  auto column = new decltype(s1len)[s1len + 1];
  std::iota(column + column_start, column + s1len + 1, column_start);

  for (auto x = column_start; x <= s2len; x++)
  {
    column[0] = x;
    auto last_diagonal = x - column_start;
    for (auto y = column_start; y <= s1len; y++)
    {
      auto old_diagonal = column[y];
      auto possibilities = {
          column[y] + 1, column[y - 1] + 1, last_diagonal + (s1[y - 1] == s2[x - 1] ? 0 : 1)};
      column[y] = std::min(possibilities);
      last_diagonal = old_diagonal;
    }
  }
  auto result = column[s1len];
  delete[] column;
  return result;
}

linearPartitionChunk()

processor_id_type MooseUtils::linearPartitionChunk	(	dof_id_type	num_items,
		dof_id_type	num_chunks,
		dof_id_type	item_id
	)

Definition at line 999 of file MooseUtils.C.

Referenced by DistributedRectilinearMeshGenerator::buildCube().

{
  auto global_num_local_items = num_items / num_chunks;

  auto leftovers = num_items % num_chunks;

  auto first_item_past_first_part = leftovers * (global_num_local_items + 1);

  // Is it in the first section (that gets an extra item)
  if (item_id < first_item_past_first_part)
    return item_id / (global_num_local_items + 1);
  else
  {
    auto new_item_id = item_id - first_item_past_first_part;

    // First chunk after the first section + the number of chunks after that
    return leftovers + (new_item_id / global_num_local_items);
  }
}

linearPartitionItems()

void MooseUtils::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
	)

Definition at line 973 of file MooseUtils.C.

Referenced by DistributedRectilinearMeshGenerator::buildCube().

{
  auto global_num_local_items = num_items / num_chunks;

  num_local_items = global_num_local_items;

  auto leftovers = num_items % num_chunks;

  if (chunk_id < leftovers)
  {
    num_local_items++;
    local_items_begin = num_local_items * chunk_id;
  }
  else
    local_items_begin =
        (global_num_local_items + 1) * leftovers + global_num_local_items * (chunk_id - leftovers);

  local_items_end = local_items_begin + num_local_items;
}

listDir()

std::list<std::string> MooseUtils::listDir	(	const std::string	path,
		bool	files_only
	)

Definition at line 782 of file MooseUtils.C.

Referenced by convertLatestCheckpoint(), getFilesInDirs(), and removedirs().

{
  std::list<std::string> files;

  tinydir_dir dir;
  dir.has_next = 0; // Avoid a garbage value in has_next (clang StaticAnalysis)
  tinydir_open(&dir, path.c_str());

  while (dir.has_next)
  {
    tinydir_file file;
    file.is_dir = 0; // Avoid a garbage value in is_dir (clang StaticAnalysis)
    tinydir_readfile(&dir, &file);

    if (!files_only || !file.is_dir)
      files.push_back(path + "/" + file.name);

    tinydir_next(&dir);
  }

  tinydir_close(&dir);

  return files;
}

makedirs()

void MooseUtils::makedirs	(	const std::string &	dir_name,
		bool	throw_on_failure
	)

Definition at line 449 of file MooseUtils.C.

{
  // split path into directories with delimiter '/'
  std::vector<std::string> split_dir_names;
  MooseUtils::tokenize(dir_name, split_dir_names);

  auto n = split_dir_names.size();

  // remove '.' and '..' when possible
  auto i = n;
  i = 0;
  while (i != n)
  {
    if (split_dir_names[i] == ".")
    {
      for (auto j = i + 1; j < n; ++j)
        split_dir_names[j - 1] = split_dir_names[j];
      --n;
    }
    else if (i > 0 && split_dir_names[i] == ".." && split_dir_names[i - 1] != "..")
    {
      for (auto j = i + 1; j < n; ++j)
        split_dir_names[j - 2] = split_dir_names[j];
      n -= 2;
      --i;
    }
    else
      ++i;
  }
  if (n == 0)
    return;

  split_dir_names.resize(n);

  // start creating directories recursively
  std::string cur_dir = dir_name[0] == '/' ? "" : ".";
  for (auto & dir : split_dir_names)
  {
    cur_dir += "/" + dir;

    if (!pathExists(cur_dir))
    {
      auto code = Utility::mkdir(cur_dir.c_str());
      if (code != 0)
      {
        std::string msg = "Failed creating directory " + dir_name;
        if (throw_on_failure)
          throw std::invalid_argument(msg);
        else
          mooseError(msg);
      }
    }
  }
}

MaterialPropertyStorageDump()

void MooseUtils::MaterialPropertyStorageDump

(

const HashMap< const libMesh::Elem *, HashMap< unsigned int, MaterialProperties >> &

props

)

Definition at line 688 of file MooseUtils.C.

{
  // Loop through the elements
  for (const auto & elem_it : props)
  {
    Moose::out << "Element " << elem_it.first->id() << '\n';

    // Loop through the sides
    for (const auto & side_it : elem_it.second)
    {
      Moose::out << "  Side " << side_it.first << '\n';

      // Loop over properties
      unsigned int cnt = 0;
      for (const auto & mat_prop : side_it.second)
      {
        if (auto mp = dynamic_cast<const MaterialProperty<Real> *>(&mat_prop))
        {
          Moose::out << "    Property " << cnt << '\n';
          cnt++;

          // Loop over quadrature points
          for (unsigned int qp = 0; qp < mp->size(); ++qp)
            Moose::out << "      prop[" << qp << "] = " << (*mp)[qp] << '\n';
        }
      }
    }
  }

  Moose::out << std::flush;
}

mooseDocsURL()

std::string MooseUtils::mooseDocsURL

(

const std::string &

path

)

Definition at line 139 of file MooseUtils.C.

Referenced by ExecFlagEnum::getDocString().

{
  return "https://mooseframework.inl.gov/" + path;
}

parallelBarrierNotify()

void MooseUtils::parallelBarrierNotify	(	const Parallel::Communicator &	comm,
		bool	messaging
	)

Definition at line 327 of file MooseUtils.C.

Referenced by FEProblemBase::backupMultiApps(), FEProblemBase::execMultiApps(), FEProblemBase::execMultiAppTransfers(), FEProblemBase::finishMultiAppStep(), and FEProblemBase::restoreMultiApps().

{
  processor_id_type secondary_processor_id;

  if (messaging)
    Moose::out << "Waiting For Other Processors To Finish" << std::endl;
  if (comm.rank() == 0)
  {
    // The primary process is already through, so report it
    if (messaging)
      Moose::out << "Jobs complete: 1/" << comm.size() << (1 == comm.size() ? "\n" : "\r")
                 << std::flush;
    for (unsigned int i = 2; i <= comm.size(); ++i)
    {
      comm.receive(MPI_ANY_SOURCE, secondary_processor_id);
      if (messaging)
        Moose::out << "Jobs complete: " << i << "/" << comm.size()
                   << (i == comm.size() ? "\n" : "\r") << std::flush;
    }
  }
  else
  {
    secondary_processor_id = comm.rank();
    comm.send(0, secondary_processor_id);
  }

  comm.barrier();
}

parsesToReal()

bool MooseUtils::parsesToReal	(	const std::string &	input,
		Real *	parsed_real
	)

Definition at line 89 of file MooseUtils.C.

Referenced by DiffusionCG::addFEBCs(), DiffusionCG::addFEKernels(), DiffusionFV::addFVBCs(), DiffusionFV::addFVKernels(), FunctorExtremaPositions::FunctorExtremaPositions(), FunctorIC::FunctorIC(), and RankTwoTensorFromComponentProperties::RankTwoTensorFromComponentProperties().

{
  std::istringstream ss(input);
  Real real_value;
  if (ss >> real_value && ss.eof())
  {
    if (parsed_real)
      (*parsed_real) = real_value;
    return true;
  }
  return false;
}

pathContains()

bool MooseUtils::pathContains	(	const std::string &	expression,
		const std::string &	string_to_find,
		const std::string &	delims
	)

Definition at line 231 of file MooseUtils.C.

{
  std::vector<std::string> elements;
  tokenize(expression, elements, 0, delims);

  std::vector<std::string>::iterator found_it =
      std::find(elements.begin(), elements.end(), string_to_find);
  if (found_it != elements.end())
    return true;
  else
    return false;
}

pathExists()

bool MooseUtils::pathExists

(

const std::string &

path

)

Definition at line 247 of file MooseUtils.C.

Referenced by MooseApp::copyInputs(), FileMeshGenerator::deduceCheckpointPath(), docsDir(), findTestRoot(), installedInputsDir(), RestartableDataReader::isAvailable(), makedirs(), removedirs(), MooseApp::run(), and runTestsExecutable().

{
  struct stat buffer;
  return (stat(path.c_str(), &buffer) == 0);
}

pathjoin()

std::filesystem::path MooseUtils::pathjoin

(

const std::filesystem::path &

p

)

Definition at line 59 of file MooseUtils.C.

Referenced by Registry::addAppDataFilePath(), Registry::determineDataFilePath(), docsDir(), findTestRoot(), Moose::DataFileUtils::getPath(), installedInputsDir(), ADFParser::JITCompile(), MooseApp::loadLibraryAndDependencies(), MooseApp::run(), and runTestsExecutable().

{
  return p;
}

prettyCppType()

std::string MooseUtils::prettyCppType

(

const std::string &

cpp_type

)

Definition at line 1140 of file MooseUtils.C.

Referenced by MooseServer::addParametersToList(), MooseServer::addValuesToList(), InputParametersChecksUtils< BatchMeshGeneratorAction >::assertParamDefined(), ReporterGeneralContext< T >::contextType(), ReporterBroadcastContext< T >::contextType(), ReporterScatterContext< T >::contextType(), ReporterGatherContext< T >::contextType(), ReporterVectorContext< T >::contextType(), Moose::Kokkos::dataLoad(), FunctorSmootherTempl< T >::FunctorSmootherTempl(), MooseServer::gatherDocumentDefinitionLocations(), MooseServer::getFileNameTypeValues(), MooseServer::getNodesByValueAndTypes(), ThreadedElementLoop< ConstElemPointerRange >::printExecutionOrdering(), Moose::ParameterRegistry::set(), JsonSyntaxTree::setParams(), and MFEMProblem::solverTypeString().

{
  // On mac many of the std:: classes are inline namespaced with __1
  // On linux std::string can be inline namespaced with __cxx11
  std::string s = cpp_type;
  // Remove all spaces surrounding a >
  pcrecpp::RE("\\s(?=>)").GlobalReplace("", &s);
  pcrecpp::RE("std::__\\w+::").GlobalReplace("std::", &s);
  // It would be nice if std::string actually looked normal
  pcrecpp::RE("\\s*std::basic_string<char, std::char_traits<char>, std::allocator<char>>\\s*")
      .GlobalReplace("std::string", &s);
  // It would be nice if std::vector looked normal
  pcrecpp::RE r("std::vector<([[:print:]]+),\\s?std::allocator<\\s?\\1\\s?>\\s?>");
  r.GlobalReplace("std::vector<\\1>", &s);
  // Do it again for nested vectors
  r.GlobalReplace("std::vector<\\1>", &s);
  // It would be nice if std::map and unordered map looked normal
  pcrecpp::RE r_map(
      "std::map<\\s*((?:[^,<]|<[^>]*>)+)\\s*,\\s*((?:[^,<]|<[^>]*>)+)\\s*,\\s*"
      "std::less<\\s*\\1\\s*>\\s*,\\s*"
      "std::allocator<\\s*std::pair<\\s*(?:const\\s*\\1|\\1\\s*const)\\s*,\\s*\\2\\s*>\\s*>\\s*>");
  r_map.GlobalReplace("std::map<\\1, \\2>", &s);
  pcrecpp::RE r_umap(
      "std::unordered_map<\\s*([^,]+)\\s*,\\s*([^,]+)\\s*,\\s*"
      "std::hash<\\s*\\1\\s*>\\s*,\\s*"
      "std::equal_to<\\s*\\1\\s*>\\s*,\\s*"
      "std::allocator<\\s*std::pair<\\s*(?:const\\s*\\1|\\1\\s*const)\\s*,\\s*\\2\\s*>\\s*>\\s*>");
  r_umap.GlobalReplace("std::unordered_map<\\1, \\2>", &s);

  return s;
}

realpath()

std::string MooseUtils::realpath

(

const std::string &

path

)

Definition at line 1125 of file MooseUtils.C.

Referenced by Parser::parse(), and MooseApp::run().

{
  return std::filesystem::absolute(path);
}

removeColor()

std::string& MooseUtils::removeColor

(

std::string &

msg

)

Definition at line 722 of file MooseUtils.C.

Referenced by Console::writeStreamToFile().

{
  pcrecpp::RE re("(\\33\\[3[0-7]m))", pcrecpp::DOTALL());
  re.GlobalReplace(std::string(""), &msg);
  return msg;
}

removedirs()

void MooseUtils::removedirs	(	const std::string &	dir_name,
		bool	throw_on_failure
	)

Definition at line 505 of file MooseUtils.C.

{
  // split path into directories with delimiter '/'
  std::vector<std::string> split_dir_names;
  MooseUtils::tokenize(dir_name, split_dir_names);

  auto n = split_dir_names.size();

  // remove '.' and '..' when possible
  auto i = n;
  i = 0;
  while (i != n)
  {
    if (split_dir_names[i] == ".")
    {
      for (auto j = i + 1; j < n; ++j)
        split_dir_names[j - 1] = split_dir_names[j];
      --n;
    }
    else if (i > 0 && split_dir_names[i] == ".." && split_dir_names[i - 1] != "..")
    {
      for (auto j = i + 1; j < n; ++j)
        split_dir_names[j - 2] = split_dir_names[j];
      n -= 2;
      --i;
    }
    else
      ++i;
  }
  if (n == 0)
    return;

  split_dir_names.resize(n);

  // start removing directories recursively
  std::string base_dir = dir_name[0] == '/' ? "" : ".";
  for (i = n; i > 0; --i)
  {
    std::string cur_dir = base_dir;
    auto j = i;
    for (j = 0; j < i; ++j)
      cur_dir += "/" + split_dir_names[j];

    // listDir should return at least '.' and '..'
    if (pathExists(cur_dir) && listDir(cur_dir).size() == 2)
    {
      auto code = rmdir(cur_dir.c_str());
      if (code != 0)
      {
        std::string msg = "Failed removing directory " + dir_name;
        if (throw_on_failure)
          throw std::invalid_argument(msg);
        else
          mooseError(msg);
      }
    }
    else
      // stop removing
      break;
  }
}

removeExtraWhitespace()

std::string MooseUtils::removeExtraWhitespace

(

const std::string &

input

)

Definition at line 225 of file MooseUtils.C.

Referenced by CommandLine::initSubAppCommandLine(), and CommandLine::parse().

{
  return std::regex_replace(input, std::regex("^\\s+|\\s+$|\\s+(?=\\s)"), "");
}

replaceAll()

std::string MooseUtils::replaceAll	(	std::string	str,
		const std::string &	from,
		const std::string &	to
	)

Definition at line 145 of file MooseUtils.C.

Referenced by ReporterDebugOutput::output(), and MooseUtils::DelimitedFileReaderTempl< T >::processLine().

{
  size_t start_pos = 0;
  while ((start_pos = str.find(from, start_pos)) != std::string::npos)
  {
    str.replace(start_pos, from.length(), to);
    start_pos += to.length(); // Handles case where 'to' is a substring of 'from'
  }
  return str;
}

replaceStart()

void MooseUtils::replaceStart	(	std::string &	string1,
		const std::string &	string2,
		const std::string &	string3
	)

Definition at line 1187 of file MooseUtils.C.

{
  mooseAssert(startsWith(string1, string2),
              "Cannot replace the start because it doesn't match the start string");
  string1.replace(0, string2.size(), string3);
}

resample() [1/4]

template<typename T >

std::vector< T > MooseUtils::resample	(	const std::vector< T > &	data,
		MooseRandom &	generator,
		const std::size_t	seed_index = 0
	)

Randomly resample a vector of data, allowing a value to be repeated.

Parameters

data	The vector on which the values are to be swapped
generator	Random number generator to use for shuffle
seed_index	(default: 0) The seed index to use for calls to randl
comm_ptr	Optional Communicator, if provided and running with multiple processors the vector is assumed to be distributed

Definition at line 531 of file Shuffle.h.

Referenced by resample().

{
  return MooseUtils::resample(data, generator, seed_index, nullptr);
}

resample() [2/4]

template<typename T >

std::vector< T > MooseUtils::resample	(	const std::vector< T > &	data,
		MooseRandom &	generator,
		const libMesh::Parallel::Communicator &	comm
	)

Definition at line 540 of file Shuffle.h.

{
  return MooseUtils::resample(data, generator, 0, &comm);
}

resample() [3/4]

template<typename T >

std::vector< T > MooseUtils::resample	(	const std::vector< T > &	data,
		MooseRandom &	generator,
		const std::size_t	seed_index,
		const libMesh::Parallel::Communicator &	comm
	)

Definition at line 549 of file Shuffle.h.

{
  return MooseUtils::resample(data, generator, seed_index, &comm);
}

resample() [4/4]

template<typename T >

std::vector< T > MooseUtils::resample	(	const std::vector< T > &	data,
		MooseRandom &	generator,
		const std::size_t	seed_index,
		const libMesh::Parallel::Communicator *	comm_ptr
	)

Definition at line 335 of file Shuffle.h.

{
  // Size of the local input data
  const std::size_t n_local = data.size();

  // Re-sampled data vector to be returned
  std::vector<T> replicate(n_local);

  // REPLICATED data
  if (!comm_ptr || comm_ptr->size() == 1)
  {
    replicate.resize(n_local);
    for (std::size_t j = 0; j < n_local; ++j)
    {
      auto index = generator.randl(seed_index, 0, n_local);
      replicate[j] = data[index];
    }
  }

  // DISTRIBUTED data
  else
  {
    // Compute the global size of the vector
    std::size_t n_global = n_local;
    comm_ptr->sum(n_global);

    // Compute the vector data offsets, the scope cleans up the "n_local" vector
    std::vector<std::size_t> offsets(comm_ptr->size());
    {
      std::vector<std::size_t> local_sizes;
      comm_ptr->allgather(n_local, local_sizes);
      for (std::size_t i = 0; i < local_sizes.size() - 1; ++i)
        offsets[i + 1] = offsets[i] + local_sizes[i];
    }

    // Advance the random number generator to the current offset
    const auto rank = comm_ptr->rank();
    for (std::size_t i = 0; i < offsets[rank]; ++i)
      generator.randl(seed_index, 0, n_global);

    // Compute the needs for this processor
    std::unordered_map<processor_id_type, std::vector<std::pair<std::size_t, std::size_t>>> needs;
    for (std::size_t i = 0; i < n_local; ++i)
    {
      const auto idx = generator.randl(seed_index, 0, n_global); // random global index

      // Locate the rank and local index of the data desired
      const auto idx_offset_iter = std::prev(std::upper_bound(offsets.begin(), offsets.end(), idx));
      const auto idx_rank = std::distance(offsets.begin(), idx_offset_iter);
      const auto idx_local_idx = idx - *idx_offset_iter;

      // Local available data can be inserted into the re-sample, non-local data is add the the
      // needs from other ranks
      if (idx_rank == rank)
        replicate[i] = data[idx_local_idx];
      else
        needs[idx_rank].emplace_back(idx_local_idx, i);
    }

    // Advance the random number generator to the end of the global vector
    for (std::size_t i = offsets[rank] + n_local; i < n_global; ++i)
      generator.randl(seed_index, 0, n_global);

    // Collect the values to be returned to the various processors
    std::unordered_map<processor_id_type, std::vector<std::pair<T, std::size_t>>> returns;
    auto return_functor =
        [&data, &returns](processor_id_type pid,
                          const std::vector<std::pair<std::size_t, std::size_t>> & indices)
    {
      auto & returns_pid = returns[pid];
      for (const auto & idx : indices)
        returns_pid.emplace_back(data[idx.first], idx.second);
    };
    Parallel::push_parallel_vector_data(*comm_ptr, needs, return_functor);

    // Receive resampled values from the various processors
    auto recv_functor =
        [&replicate](processor_id_type, const std::vector<std::pair<T, std::size_t>> & values)
    {
      for (const auto & value : values)
        replicate[value.second] = value.first;
    };
    Parallel::push_parallel_vector_data(*comm_ptr, returns, recv_functor);
  }
  return replicate;
}

resampleWithFunctor() [1/4]

template<typename T , typename ActionFunctor >

void MooseUtils::resampleWithFunctor	(	const std::vector< T > &	data,
		const ActionFunctor &	functor,
		MooseRandom &	generator,
		const std::size_t	seed_index = 0
	)

Randomly resample a vector of data and apply a functor, allowing a value to be repeated.

Parameters

data	The vector on which the values are to be swapped
functor	Functor to apply to each entry of the resampled vector
generator	Random number generator to use for shuffle
seed_index	(default: 0) The seed index to use for calls to randl
comm_ptr	Optional Communicator, if provided and running with multiple processors the vector is assumed to be distributed

Definition at line 559 of file Shuffle.h.

Referenced by resampleWithFunctor().

{
  return MooseUtils::resampleWithFunctor(data, functor, generator, seed_index, nullptr);
}

resampleWithFunctor() [2/4]

template<typename T , typename ActionFunctor >

void MooseUtils::resampleWithFunctor	(	const std::vector< T > &	data,
		const ActionFunctor &	functor,
		MooseRandom &	generator,
		const libMesh::Parallel::Communicator &	comm
	)

Definition at line 569 of file Shuffle.h.

{
  return MooseUtils::resampleWithFunctor(data, functor, generator, 0, &comm);
}

resampleWithFunctor() [3/4]

template<typename T , typename ActionFunctor >

void MooseUtils::resampleWithFunctor	(	const std::vector< T > &	data,
		const ActionFunctor &	functor,
		MooseRandom &	generator,
		const std::size_t	seed_index,
		const libMesh::Parallel::Communicator &	comm
	)

Definition at line 579 of file Shuffle.h.

{
  return MooseUtils::resampleWithFunctor(data, functor, generator, seed_index, &comm);
}

resampleWithFunctor() [4/4]

template<typename T , typename ActionFunctor >

void MooseUtils::resampleWithFunctor	(	const std::vector< T > &	data,
		const ActionFunctor &	functor,
		MooseRandom &	generator,
		const std::size_t	seed_index,
		const libMesh::Parallel::Communicator *	comm_ptr
	)

Definition at line 427 of file Shuffle.h.

{
  const std::size_t n_local = data.size();

  if (!comm_ptr || comm_ptr->size() == 1)
  {
    for (std::size_t j = 0; j < n_local; ++j)
    {
      auto index = generator.randl(seed_index, 0, n_local);
      functor(data[index]);
    }
  }
  else
  {
    // Compute the global size of the vector
    std::size_t n_global = n_local;
    comm_ptr->sum(n_global);

    // Compute the vector data offsets, the scope cleans up the "n_local" vector
    std::vector<std::size_t> offsets(comm_ptr->size());
    {
      std::vector<std::size_t> local_sizes;
      comm_ptr->allgather(n_local, local_sizes);
      for (std::size_t i = 0; i < local_sizes.size() - 1; ++i)
        offsets[i + 1] = offsets[i] + local_sizes[i];
    }

    // Advance the random number generator to the current offset
    const auto rank = comm_ptr->rank();
    for (std::size_t i = 0; i < offsets[rank]; ++i)
      generator.randl(seed_index, 0, n_global);

    // Compute the needs for this processor
    std::unordered_map<processor_id_type, std::vector<std::size_t>> indices;
    for (std::size_t i = 0; i < n_local; ++i)
    {
      const auto idx = generator.randl(seed_index, 0, n_global); // random global index

      // Locate the rank and local index of the data desired
      const auto idx_offset_iter = std::prev(std::upper_bound(offsets.begin(), offsets.end(), idx));
      const auto idx_rank = std::distance(offsets.begin(), idx_offset_iter);
      const auto idx_local_idx = idx - *idx_offset_iter;

      // Push back the index to appropriate rank
      indices[idx_rank].push_back(idx_local_idx);
    }

    // Advance the random number generator to the end of the global vector
    for (std::size_t i = offsets[rank] + n_local; i < n_global; ++i)
      generator.randl(seed_index, 0, n_global);

    // Send the indices to the appropriate rank and have the calculator do its work
    auto act_functor =
        [&functor, &data](processor_id_type /*pid*/, const std::vector<std::size_t> & indices)
    {
      for (const auto & idx : indices)
        functor(data[idx]);
    };
    Parallel::push_parallel_vector_data(*comm_ptr, indices, act_functor);
  }
}

reset() [1/2]

template<class T , typename... Args>

auto MooseUtils::reset	(	int	,
		T &	obj,
		Args...	args
	)		-> decltype(obj.reset(args...), void())

Definition at line 21 of file SharedPool.h.

Referenced by MooseUtils::SharedPool< T >::acquire().

{
  obj.reset(std::forward<Args>(args)...);
}

reset() [2/2]

template<class T , typename... Args>

void MooseUtils::reset	(	double	,
		T &	,
		Args...
	)

Definition at line 28 of file SharedPool.h.

{
}

rsplit()

std::vector<std::string> MooseUtils::rsplit	(	const std::string &	str,
		const std::string &	delimiter,
		std::size_t	max_count
	)

Definition at line 1040 of file MooseUtils.C.

{
  std::vector<std::string> output;
  std::size_t count = 0;
  size_t prev = str.length(), pos = str.length();
  do
  {
    pos = str.rfind(delimiter, prev);
    output.insert(output.begin(), str.substr(pos + delimiter.length(), prev - pos));
    prev = pos - delimiter.length();
    count += 1;
  } while (pos != std::string::npos && pos > 0 && count < max_count);

  if (pos != std::string::npos)
    output.insert(output.begin(), str.substr(0, pos));

  return output;
}

runTestsExecutable()

std::string MooseUtils::runTestsExecutable

(

)

Definition at line 65 of file MooseUtils.C.

Referenced by MooseApp::runInputs().

{
  auto build_loc = pathjoin(Moose::getExecutablePath(), "run_tests");
  if (pathExists(build_loc) && checkFileReadable(build_loc))
    return build_loc;
  // TODO: maybe no path prefix - just moose_test_runner here?
  return pathjoin(Moose::getExecutablePath(), "moose_test_runner");
}

serialBegin()

void MooseUtils::serialBegin	(	const libMesh::Parallel::Communicator &	comm,
		bool	warn
	)

Definition at line 357 of file MooseUtils.C.

Referenced by SerializerGuard::SerializerGuard().

{
  // unless we are the first processor...
  if (comm.rank() > 0)
  {
    // ...wait for the previous processor to finish
    int dummy = 0;
    comm.receive(comm.rank() - 1, dummy);
  }
  else if (warn)
    mooseWarning("Entering serial execution block (use only for debugging)");
}

serialEnd()

void MooseUtils::serialEnd	(	const libMesh::Parallel::Communicator &	comm,
		bool	warn
	)

Definition at line 371 of file MooseUtils.C.

Referenced by SerializerGuard::~SerializerGuard().

{
  // unless we are the last processor...
  if (comm.rank() + 1 < comm.size())
  {
    // ...notify the next processor of its turn
    int dummy = 0;
    comm.send(comm.rank() + 1, dummy);
  }

  comm.barrier();
  if (comm.rank() == 0 && warn)
    mooseWarning("Leaving serial execution block (use only for debugging)");
}

shortName()

std::string MooseUtils::shortName

(

const std::string &

name

)

Definition at line 612 of file MooseUtils.C.

Referenced by InputParameterWarehouse::addInputParameters(), ActionFactory::create(), CSV::getVectorPostprocessorFileName(), CSV::getVectorPostprocessorFilePrefix(), and CSV::initialSetup().

{
  return name.substr(name.find_last_of('/') != std::string::npos ? name.find_last_of('/') + 1 : 0);
}

shuffle() [1/4]

template<typename T >

void MooseUtils::shuffle	(	std::vector< T > &	data,
		MooseRandom &	generator,
		const std::size_t	seed_index = 0
	)

Shuffle function for serial or distributed vector of data that shuffles in place.

Parameters

data	The vector on which the values are to be swapped
generator	Random number generator to use for shuffle
seed_index	(default: 0) The seed index to use for calls to randl
comm_ptr	Optional Communicator, if provided and running with multiple processors the vector is assumed to be distributed

Both the serial and distributed version implement a Fisher-Yates shuffle https://en.wikipedia.org/wiki/Fisher%E2%80%93Yates_shuffle

NOTE: This distributed shuffle I have here does a parallel communication with each swap pair generated. I am certain that there are more efficient ways to shuffle a distributed vector, but there doesn't seem to be an algorithm in the literature (my search was not extensive).

The reason I came to this conclusion was because of a 2019 paper, which states the following (https://iopscience.iop.org/article/10.1088/1742-6596/1196/1/012035):

The study also says that the Fisher-Yates Shuffle can be developed in two ways,
namely the algorithm's initial assumptions that allow for discrete uniform variables,
and also with the avent of large core clusters and GPUs, there is an interest in making
parallel versions of this algorithm.

This paper discusses the MergeShuffle (https://arxiv.org/abs/1508.03167), but that is a shared memory parallel algorithm.

Hence, if you want to become famous create a parallel Fisher-Yates algorithm for MPI.

Definition at line 505 of file Shuffle.h.

Referenced by shuffle().

{
  return MooseUtils::shuffle(data, generator, seed_index, nullptr);
}

shuffle() [2/4]

template<typename T >

void MooseUtils::shuffle	(	std::vector< T > &	data,
		MooseRandom &	generator,
		const libMesh::Parallel::Communicator &	comm
	)

Definition at line 512 of file Shuffle.h.

{
  return MooseUtils::shuffle(data, generator, 0, &comm);
}

shuffle() [3/4]

template<typename T >

void MooseUtils::shuffle	(	std::vector< T > &	data,
		MooseRandom &	generator,
		const std::size_t	seed_index,
		const libMesh::Parallel::Communicator &	comm
	)

Definition at line 521 of file Shuffle.h.

{
  return MooseUtils::shuffle(data, generator, seed_index, &comm);
}

shuffle() [4/4]

template<typename T >

void MooseUtils::shuffle	(	std::vector< T > &	data,
		MooseRandom &	generator,
		const std::size_t	seed_index,
		const libMesh::Parallel::Communicator *	comm_ptr
	)

Definition at line 244 of file Shuffle.h.

{
  // REPLICATED data
  if (!comm_ptr || comm_ptr->size() == 1)
  {
    std::size_t n_global = data.size();
    for (std::size_t i = n_global - 1; i > 0; --i)
    {
      auto j = generator.randl(seed_index, 0, i);
      MooseUtils::swap(data, i, j, nullptr);
    }
  }

  // DISTRIBUTED data
  else
  {
    // Local/global size
    std::size_t n_local = data.size();
    std::size_t n_global = n_local;
    comm_ptr->sum(n_global);

    // Compute the vector data offsets, the scope cleans up the "n_local" vector
    std::vector<std::size_t> offsets(comm_ptr->size());
    {
      std::vector<std::size_t> local_sizes;
      comm_ptr->allgather(n_local, local_sizes);
      for (std::size_t i = 0; i < local_sizes.size() - 1; ++i)
        offsets[i + 1] = offsets[i] + local_sizes[i];
    }

    // Perform swaps
    auto rank = comm_ptr->rank();
    for (std::size_t idx0 = n_global - 1; idx0 > 0; --idx0)
    {
      auto idx1 = generator.randl(seed_index, 0, idx0);

      // Locate the rank and local index of the data to swap
      auto idx0_offset_iter = std::prev(std::upper_bound(offsets.begin(), offsets.end(), idx0));
      auto idx0_rank = std::distance(offsets.begin(), idx0_offset_iter);
      auto idx0_local_idx = idx0 - *idx0_offset_iter;

      auto idx1_offset_iter = std::prev(std::upper_bound(offsets.begin(), offsets.end(), idx1));
      auto idx1_rank = std::distance(offsets.begin(), idx1_offset_iter);
      auto idx1_local_idx = idx1 - *idx1_offset_iter;

      // The values, if any, needed from other rank
      std::unordered_map<processor_id_type, std::vector<std::size_t>> needs;
      if (idx0_rank != rank && idx1_rank == rank)
        needs[idx0_rank].push_back(idx0_local_idx);
      if (idx0_rank == rank && idx1_rank != rank)
        needs[idx1_rank].push_back(idx1_local_idx);

      // Collect the values needed by this processor
      std::unordered_map<processor_id_type, std::vector<T>> returns;
      auto return_functor =
          [&data, &returns](processor_id_type pid, const std::vector<std::size_t> & indices)
      {
        auto & returns_pid = returns[pid];
        for (auto idx : indices)
          returns_pid.push_back(data[idx]);
      };
      Parallel::push_parallel_vector_data(*comm_ptr, needs, return_functor);

      // Receive needed values from the others processors
      std::vector<T> incoming;
      auto recv_functor = [&incoming](processor_id_type /*pid*/, const std::vector<T> & values)
      { incoming = values; };
      Parallel::push_parallel_vector_data(*comm_ptr, returns, recv_functor);

      if (idx0_rank == rank && idx1_rank == rank)
        MooseUtils::swap(data, idx0_local_idx, idx1_local_idx);

      else if (idx0_rank == rank)
      {
        mooseAssert(incoming.size() == 1, "Only one value should be received");
        data[idx0_local_idx] = incoming[0];
      }
      else if (idx1_rank == rank)
      {
        mooseAssert(incoming.size() == 1, "Only one value should be received");
        data[idx1_local_idx] = incoming[0];
      }
    }
  }
}

split()

std::vector<std::string> MooseUtils::split	(	const std::string &	str,
		const std::string &	delimiter,
		std::size_t	max_count
	)

Definition at line 1020 of file MooseUtils.C.

Referenced by BatchMeshGeneratorAction::convertStringToCompoundRealScalar(), MeshGenerator::generateInternal(), MultiApp::getCommandLineArgs(), Moose::ParameterRegistration::setDoubleVectorValue(), and MooseApp::setMFEMDevice().

{
  std::vector<std::string> output;
  std::size_t count = 0;
  size_t prev = 0, pos = 0;
  do
  {
    pos = str.find(delimiter, prev);
    output.push_back(str.substr(prev, pos - prev));
    prev = pos + delimiter.length();
    count += 1;
  } while (pos != std::string::npos && count < max_count);

  if (pos != std::string::npos)
    output.push_back(str.substr(prev));

  return output;
}

startsWith()

bool MooseUtils::startsWith	(	const std::string &	string1,
		const std::string &	string2
	)

Definition at line 1179 of file MooseUtils.C.

Referenced by replaceStart().

{
  if (string2.size() > string1.size())
    return false;
  return string1.compare(0, string2.size(), string2) == 0;
}

stringJoin()

std::string MooseUtils::stringJoin ( const std::vector< std::string > &  values, const std::string &  separator = " "  )

inline

Concatenates value into a single string separated by separator.

Definition at line 201 of file MooseStringUtils.h.

Referenced by InputParameters::addCommandLineParamHelper(), Moose::Builder::build(), InputParameters::checkParams(), Moose::Capability::enumerationToString(), Parser::joinErrorMessages(), Parser::parse(), ParsedPostprocessor::ParsedPostprocessor(), and MFEMProblem::solverTypeString().

{
  std::string combined;
  for (const auto & value : values)
    combined += value + separator;
  if (values.size())
    combined = combined.substr(0, combined.size() - separator.size());
  return combined;
}

stringToInteger()

int MooseUtils::stringToInteger	(	const std::string &	input,
		bool	throw_on_failure
	)

Definition at line 967 of file MooseUtils.C.

Referenced by FormattedTable::printTable().

{
  return convert<int>(input, throw_on_failure);
}

stripExtension()

std::string MooseUtils::stripExtension	(	const std::string &	s,
		const bool	rfind
	)

Definition at line 427 of file MooseUtils.C.

Referenced by SplitMeshAction::act(), CommonOutputAction::act(), and SetupMeshAction::modifyParamsForUseSplit().

{
  const std::string ext = getExtension(s, rfind);
  const bool offset = (ext.size() != 0);
  // -1 offset accounts for the extension's leading dot ("."), if there is an extension
  return s.substr(0, s.size() - ext.size() - offset);
}

swap() [1/2]

template<typename T >

void MooseUtils::swap	(	std::vector< T > &	data,
		const std::size_t	idx0,
		const std::size_t	idx1,
		const libMesh::Parallel::Communicator &	comm
	)

Swap function for serial or distributed vector of data.

Parameters

data	The vector on which the values are to be swapped
idx0,idx1	The global indices to be swapped
comm_ptr	Optional Communicator, if provided and running with multiple processors the vector is assumed to be distributed

Definition at line 495 of file Shuffle.h.

Referenced by Syntax::addDependencySets(), AllNodesSendListThread::AllNodesSendListThread(), Moose::applyIndices(), AutomaticMortarGeneration::buildMortarSegmentMesh(), RestartableDataReader::clear(), FunctionPeriodicBoundary::FunctionPeriodicBoundary(), AdvancedExtruderGenerator::generate(), DistributedRectilinearMeshGenerator::paritionSquarely(), MaterialPropertyStorage::shift(), shuffle(), swap(), MooseUtils::StaticallyAllocatedSet< T, N >::swap(), MooseArray< libMesh::VectorValue >::swap(), Moose::Kokkos::MapBase< unsigned int, unsigned int >::swap(), MooseUtils::Buffer< T >::swap(), and ElementSubdomainModifierBase::timestepSetup().

{
  MooseUtils::swap<T>(data, idx0, idx1, &comm);
}

swap() [2/2]

template<typename T >

void MooseUtils::swap	(	std::vector< T > &	data,
		const std::size_t	idx0,
		const std::size_t	idx1,
		const libMesh::Parallel::Communicator *	comm_ptr = nullptr
	)

Definition at line 156 of file Shuffle.h.

{
  if (!comm_ptr || comm_ptr->size() == 1)
  {
    mooseAssert(idx0 < data.size(),
                "idx0 (" << idx0 << ") out of range, data.size() is " << data.size());
    mooseAssert(idx1 < data.size(),
                "idx1 (" << idx1 << ") out of range, data.size() is " << data.size());
    std::swap(data[idx0], data[idx1]);
  }

  else
  {
    // Size of the local input data
    const auto n_local = data.size();
    const auto rank = comm_ptr->rank();

    // Compute the global size of the vector
    std::size_t n_global = n_local;
    comm_ptr->sum(n_global);
    mooseAssert(idx0 < n_global,
                "idx0 (" << idx0 << ") out of range, the global data size is " << n_global);
    mooseAssert(idx1 < n_global,
                "idx1 (" << idx1 << ") out of range, the global data size is " << n_global);

    // Compute the vector data offsets, the scope cleans up the "n_local" vector
    std::vector<std::size_t> offsets(comm_ptr->size());
    {
      std::vector<std::size_t> local_sizes;
      comm_ptr->allgather(n_local, local_sizes);
      for (std::size_t i = 0; i < local_sizes.size() - 1; ++i)
        offsets[i + 1] = offsets[i] + local_sizes[i];
    }

    // Locate the rank and local index of the data to swap
    auto idx0_offset_iter = std::prev(std::upper_bound(offsets.begin(), offsets.end(), idx0));
    auto idx0_rank = std::distance(offsets.begin(), idx0_offset_iter);
    auto idx0_local_idx = idx0 - *idx0_offset_iter;

    auto idx1_offset_iter = std::prev(std::upper_bound(offsets.begin(), offsets.end(), idx1));
    auto idx1_rank = std::distance(offsets.begin(), idx1_offset_iter);
    auto idx1_local_idx = idx1 - *idx1_offset_iter;

    // The values, if any, needed from other rank
    std::unordered_map<processor_id_type, std::vector<std::size_t>> needs;
    if (idx0_rank != rank && idx1_rank == rank)
      needs[idx0_rank].push_back(idx0_local_idx);
    if (idx0_rank == rank && idx1_rank != rank)
      needs[idx1_rank].push_back(idx1_local_idx);

    // Collect the values needed by this processor
    std::unordered_map<processor_id_type, std::vector<T>> returns;
    auto return_functor =
        [&data, &returns](processor_id_type pid, const std::vector<std::size_t> & indices)
    {
      auto & returns_pid = returns[pid];
      for (auto idx : indices)
        returns_pid.push_back(data[idx]);
    };
    Parallel::push_parallel_vector_data(*comm_ptr, needs, return_functor);

    // Receive needed values from the others processors
    std::vector<T> incoming;
    auto recv_functor = [&incoming](processor_id_type /*pid*/, const std::vector<T> & values)
    { incoming = values; };
    Parallel::push_parallel_vector_data(*comm_ptr, returns, recv_functor);

    if (idx0_rank == rank && idx1_rank == rank)
      MooseUtils::swap(data, idx0_local_idx, idx1_local_idx);

    else if (idx0_rank == rank)
    {
      mooseAssert(incoming.size() == 1, "Only one value should be received");
      data[idx0_local_idx] = incoming[0];
    }
    else if (idx1_rank == rank)
    {
      mooseAssert(incoming.size() == 1, "Only one value should be received");
      data[idx1_local_idx] = incoming[0];
    }
  }
}

tokenize()

template<typename T >

void MooseUtils::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 passed in vector.

The delimiters default to "/" but may be supplied as well. In addition if min_len is supplied, the minimum token length will be >= than the supplied value. T should be std::string or a MOOSE derived string class.

Definition at line 55 of file MooseStringUtils.h.

Referenced by InputParameters::addCommandLineParamHelper(), Syntax::addDependencySets(), MooseEnumBase::addEnumerationName(), MooseEnumBase::addEnumerationNames(), JsonInputFileFormatter::addLine(), InputParameters::addParamNamesToGroup(), MultiMooseEnum::eraseSetValue(), TransfiniteMeshGenerator::getDiscreteEdge(), MooseApp::getLibrarySearchPaths(), TransfiniteMeshGenerator::getParsedEdge(), Syntax::isAssociated(), makedirs(), MultiMooseEnum::operator=(), FunctionMaterialPropertyDescriptor< is_ad >::parseDependentSymbols(), FunctionMaterialPropertyDescriptor< is_ad >::parseDerivative(), pathContains(), InputFileFormatter::printParams(), MooseUtils::DelimitedFileReaderTempl< T >::readColumnData(), InputParameters::registerBuildableTypes(), removedirs(), MultiMooseEnum::setAdditionalValue(), CommandLine::setCommandLineParam(), Moose::ParameterRegistration::setTripleVectorValue(), MooseApp::showInputs(), SingleMatrixPreconditioner::SingleMatrixPreconditioner(), tokenizeAndConvert(), and wildCardMatch().

{
  elements.clear();

  std::string::size_type last_pos = str.find_first_not_of(delims, 0);
  std::string::size_type pos = str.find_first_of(delims, std::min(last_pos + min_len, str.size()));

  while (last_pos != std::string::npos)
  {
    elements.push_back(str.substr(last_pos, pos - last_pos));
    // skip delims between tokens
    last_pos = str.find_first_not_of(delims, pos);
    if (last_pos == std::string::npos)
      break;
    pos = str.find_first_of(delims, std::min(last_pos + min_len, str.size()));
  }
}

tokenizeAndConvert()

template<typename T >

bool MooseUtils::tokenizeAndConvert	(	const std::string &	str,
		std::vector< T > &	tokenized_vector,
		const std::string &	delimiter = " \t\n\v\f\r"
	)

tokenizeAndConvert splits a string using delimiter and then converts to type T.

If the conversion fails tokenizeAndConvert returns false, otherwise true.

Definition at line 162 of file MooseStringUtils.h.

Referenced by SplitMeshAction::act(), Moose::internal::CapabilityRegistry::check(), TransfiniteMeshGenerator::getCircarcEdge(), TransfiniteMeshGenerator::getDiscreteEdge(), and Moose::MFEM::CoefficientManager::getVectorCoefficientPtr().

{
  std::vector<std::string> tokens;
  MooseUtils::tokenize(str, tokens, 1, delimiter);
  tokenized_vector.resize(tokens.size());
  for (std::size_t i = 0; i < tokens.size(); ++i)
    if (!convert<T>(tokens[i], tokenized_vector[i], false))
      return false;
  return true;
}

toLower()

std::string MooseUtils::toLower ( std::string  name )

inline

Convert supplied string to lower case.

name The string to convert upper case.

Definition at line 191 of file MooseStringUtils.h.

Referenced by Registry::appNameFromAppPath(), Moose::internal::CapabilityRegistry::check(), MooseServer::getDocumentSymbolKind(), SubProblem::getVariableHelper(), ConsoleUtils::outputRelationshipManagerInformation(), MooseUtils::DelimitedFileReaderTempl< T >::processLine(), Moose::internal::CapabilityRegistry::query(), AppFactory::registerAppCapability(), Moose::PeriodicBCHelper::setupAutoPeriodicBoundaries(), and WorkBalance::WorkBalance().

{
  std::transform(name.begin(), name.end(), name.begin(), ::tolower);
  return name;
}

toUpper()

std::string MooseUtils::toUpper ( std::string  name )

inline

Convert supplied string to upper case.

name The string to convert upper case.

Definition at line 180 of file MooseStringUtils.h.

Referenced by SubProblem::addMatrixTag(), SubProblem::addVectorTag(), MooseEnumBase::find(), SubProblem::getMatrixTagID(), SubProblem::getVectorTagID(), SubProblem::matrixTagExists(), MooseEnumItem::operator!=(), MooseEnumItem::operator==(), MooseEnum::operator==(), moose::internal::ExecFlagRegistry::registerFlag(), moose::internal::ConvergenceIterationTypeRegistry::registerType(), Coupleable::vectorTagDofValueHelper(), SubProblem::vectorTagExists(), and Coupleable::vectorTagValueHelper().

{
  std::transform(name.begin(), name.end(), name.begin(), ::toupper);
  return name;
}

trim()

std::string MooseUtils::trim ( const std::string &  str, const std::string &  white_space = " \t\n\v\f\r"  )

inline

Standard scripting language trim function.

Definition at line 38 of file MooseStringUtils.h.

Referenced by MooseEnumBase::addEnumerationName(), JsonInputFileFormatter::addLine(), JsonInputFileFormatter::addParameters(), MooseServer::addParametersToList(), InputParameters::appendFunctorDescription(), MooseEnum::assign(), convert(), MooseServer::formatDocument(), MultiApp::getCommandLineArgs(), Moose::MFEM::CoefficientManager::getScalarCoefficientPtr(), TimedSubdomainModifier::getSubdomainIDAndCheck(), MooseUtils::DelimitedFileReaderTempl< T >::preprocessLine(), InputFileFormatter::printParams(), MooseUtils::DelimitedFileReaderTempl< T >::readColumnData(), Moose::ParameterRegistration::setDoubleVectorValue(), and Moose::ParameterRegistration::setTripleVectorValue().

{
  const auto begin = str.find_first_not_of(white_space);
  if (begin == std::string::npos)
    return ""; // no content
  const auto end = str.find_last_not_of(white_space);
  return str.substr(begin, end - begin + 1);
}

underscoreToCamelCase()

std::string MooseUtils::underscoreToCamelCase	(	const std::string &	underscore_name,
		bool	leading_upper_case
	)

Definition at line 580 of file MooseUtils.C.

Referenced by MooseApp::libNameToAppName(), and ConsoleUtils::outputRelationshipManagerInformation().

{
  pcrecpp::StringPiece input(underscore_name);
  pcrecpp::RE re("([^_]*)(_|$)");

  std::string result;
  std::string us, not_us;
  bool make_upper = leading_upper_case;
  while (re.Consume(&input, &not_us, &us))
  {
    if (not_us.length() > 0)
    {
      if (make_upper)
      {
        result += std::toupper(not_us[0]);
        if (not_us.length() > 1)
          result += not_us.substr(1);
      }
      else
        result += not_us;
    }
    if (us == "")
      break;

    // Toggle flag so next match is upper cased
    make_upper = true;
  }

  return result;
}

wildCardMatch()

bool MooseUtils::wildCardMatch	(	std::string	name,
		std::string	search_string
	)

Definition at line 888 of file MooseUtils.C.

Referenced by JsonSyntaxTree::addParameters(), JsonSyntaxTree::addSyntaxType(), SyntaxTree::TreeNode::print(), InputFileFormatter::printParams(), and JsonSyntaxTree::setParams().

{
  // Assume that an empty string matches anything
  if (search_string == "")
    return true;

  // transform to lower for case insenstive matching
  std::transform(name.begin(), name.end(), name.begin(), (int (*)(int))std::toupper);
  std::transform(search_string.begin(),
                 search_string.end(),
                 search_string.begin(),
                 (int (*)(int))std::toupper);

  // exact match!
  if (search_string.find("*") == std::string::npos)
    return search_string == name;

  // wildcard
  std::vector<std::string> tokens;
  MooseUtils::tokenize(search_string, tokens, 1, "*");

  size_t pos = 0;
  for (unsigned int i = 0; i < tokens.size() && pos != std::string::npos; ++i)
  {
    pos = name.find(tokens[i], pos);
    // See if we have a leading wildcard
    if (search_string[0] != '*' && i == 0 && pos != 0)
      return false;
  }

  if (pos != std::string::npos && tokens.size() > 0)
  {
    // Now see if we have a trailing wildcard
    size_t last_token_length = tokens.back().length();
    if (*search_string.rbegin() == '*' || pos == name.size() - last_token_length)
      return true;
    else
      return false;
  }
  else
    return false;
}