Namespaces
namespace	detail
namespace	IO
namespace	MPI
namespace	TMP

Classes
class	ConfigTree
class	CPUTime
	Count CPU time. More...
class	GradualSubdivision
class	GradualSubdivisionFixedNum
class	Histogram
class	ISubdivision
class	MemWatch
struct	Overloaded
struct	PolymorphicRandomAccessContainerView
class	Range
	Wraps a pair of iterators for use as a range in range-based for-loops. More...
class	RunTime
	Count the running time. More...
struct	StrongType
class	TCLAPOutput
class	UniformSubdivision

Functions
template<typename T>
std::vector< T >	excludeObjectCopy (std::vector< T > const &src_vec, std::vector< std::size_t > const &exclude_positions)
template<typename T>
void	excludeObjectCopy (std::vector< T > const &src_vec, std::vector< std::size_t > const &exclude_positions, std::vector< T > &dest_vec)
template<ranges::input_range Range>
ranges::range_reference_t< Range >	findElementOrError (Range &range, std::predicate< ranges::range_reference_t< Range > > auto &&predicate, std::invocable auto error_callback)
template<typename Map, typename Key, typename Value>
void	insertIfKeyUniqueElseError (Map &map, Key const &key, Value &&value, std::string const &error_message)
template<typename Map, typename Key>
OGS_NO_DANGLING Map::mapped_type &	getOrError (Map &map, Key const &key, std::string const &error_message)
template<typename Map, typename Key>
OGS_NO_DANGLING Map::mapped_type const &	getOrError (Map const &map, Key const &key, std::string const &error_message)
	This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
template<typename Container, typename Predicate>
OGS_NO_DANGLING Container::value_type const &	getIfOrError (Container const &container, Predicate &&predicate, std::string const &error_message)
template<ranges::input_range Range> requires std::totally_ordered<ranges::range_value_t<Range>> && std::copyable<ranges::range_value_t<Range>>
std::vector< ranges::range_value_t< Range > >	getDuplicates (Range &&range)
template<typename T>
void	makeVectorUnique (std::vector< T > &v)
template<typename T, class Compare>
void	makeVectorUnique (std::vector< T > &v, Compare comp)
template<typename ValueType, typename IndexType>
void	reorderVector (std::vector< ValueType > &v, std::vector< IndexType > const &order)
template<typename Container>
void	uniquePushBack (Container &container, typename Container::value_type const &element)
template<typename Container>
std::optional< typename Container::value_type >	findFirstNotEqualElement (Container const &container, typename Container::value_type const &element)
template<typename Container>
std::size_t	findIndex (Container const &container, typename Container::value_type const &element)
template<typename T>
void	cleanupVectorElements (std::vector< T * > &items)
template<typename T1, typename... Args>
void	cleanupVectorElements (std::vector< T1 * > &dependent_items, Args &&... args)
template<ranges::range R> requires std::is_integral_v<ranges::range_value_t<R>>
std::vector< ranges::range_value_t< R > >	sizesToOffsets (R const &sizes)
template<typename List>
constexpr bool	any_of (List const &values)
	Checks if any of the elements in the given list is true.
template<typename List>
constexpr bool	all_of (List const &values)
	Checks if all of the elements in the given list are true.
template<typename List>
constexpr bool	none_of (List const &values)
	Checks if none of the elements in the given list are true.
void	checkAndInvalidate (ConfigTree &conf)
	This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
void	checkAndInvalidate (ConfigTree *const conf)
void	checkAndInvalidate (std::unique_ptr< ConfigTree > const &conf)
	This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
ConfigTree	makeConfigTree (const std::string &filepath, const bool be_ruthless, const std::string &toplevel_tag, std::stringstream &prj_stream)
ConfigTree	makeConfigTreeFromFile (const std::string &filepath, const bool be_ruthless, const std::string &toplevel_tag)
template<typename E>
constexpr auto	to_underlying (E e) noexcept
	Converts an enumeration to its underlying type.
int	date2int (int y, int m, int d)
std::string	int2date (int date)
std::string	date2string (double ddate)
int	strDate2int (const std::string &s)
int	xmlDate2int (const std::string &s)
std::string	formatDate (std::chrono::time_point< std::chrono::system_clock > const &time)
std::string	demangle (const char *mangled_name)
template<typename T>
std::string	typeToString ()
template<typename T>
std::string	typeToString (T &&)
bool	IsFileExisting (const std::string &strFilename)
	Returns true if given file exists.
std::tuple< std::string, std::string::size_type, std::string::size_type >	getParenthesizedString (std::string const &in, char const open_char, char const close_char, std::string::size_type pos)
std::string	containsKeyword (std::string const &str, std::string const &keyword)
template<typename T>
bool	substituteKeyword (std::string &result, std::string const &parenthesized_string, std::string::size_type const begin, std::string::size_type const end, std::string const &keyword, T &data)
std::string	constructFormattedFileName (std::string const &format_specification, std::string const &mesh_name, int const timestep, double const t, int const iteration, bool const converged)
double	swapEndianness (double const &v)
std::string	dropFileExtension (std::string const &filename)
std::string	extractBaseName (std::string const &pathname)
std::string	extractBaseNameWithoutExtension (std::string const &pathname)
std::string	getFileExtension (const std::string &path)
bool	hasFileExtension (std::string const &extension, std::string const &filename)
std::string	extractPath (std::string const &pathname)
std::string	joinPaths (std::string const &pathA, std::string const &pathB)
void	removeFile (std::string const &filename)
void	removeFiles (std::vector< std::string > const &files)
bool	createOutputDirectory (std::string const &dir)
std::vector< double >	readDoublesFromBinaryFile (const std::string &filename, const std::string &project_directory)
template<typename T>
T	readBinaryValue (std::istream &in)
template float	readBinaryValue< float > (std::istream &)
template double	readBinaryValue< double > (std::istream &)
template<typename T>
std::vector< T >	readBinaryVector (std::string const &filename, std::size_t const start_element, std::size_t const num_elements)
template std::vector< float >	readBinaryVector< float > (std::string const &, std::size_t const, std::size_t const)
template std::vector< double >	readBinaryVector< double > (std::string const &, std::size_t const, std::size_t const)
template<typename T>
void	writeValueBinary (std::ostream &out, T const &val)
	write value as binary into the given output stream
template void	writeValueBinary< std::size_t > (std::ostream &, std::size_t const &)
template<typename T>
T	swapEndianness (T const &v)
template<typename T>
std::ostream &	operator<< (std::ostream &os, const Histogram< T > &h)
template std::ostream &	operator<< (std::ostream &os, const Histogram< double > &h)
void	setConsoleLogLevel (std::string const &level_string)
void	initOGSLogger (std::string const &log_level)
int	getNumberOfThreadsFromEnv (char const *env_var_name)
int	getNumberOfAssemblyThreads ()
int	getNumberOfThreads ()
int	getNumberOfChemistryThreads ()
void	traverseIncludes (xmlDoc doc, xmlNode node, std::filesystem::path const &prj_dir)
void	replaceIncludes (std::stringstream &prj_stream, std::filesystem::path const &prj_dir)
void	patchStream (std::string const &patch_file, std::stringstream &prj_stream, bool after_includes=false)
void	readAndPatchPrj (std::stringstream &prj_stream, std::string &prj_file, std::vector< std::string > &patch_files)
void	prepareProjectFile (std::stringstream &prj_stream, const std::string &filepath, const std::vector< std::string > &patch_files, bool write_prj, const std::string &out_directory)
	Applies includes and patch files to project file.
template<typename It1, typename It2, typename Comparator>
void	quicksort (It1 first1, It1 last1, It2 first2, Comparator compare)
template<typename It1, typename It2>
void	quicksort (It1 first1, It1 last1, It2 first2)
template<typename T1, typename T2 = std::size_t>
void	quicksort (T1 array, std::size_t beg, std::size_t end, T2 perm)
template<typename T1, typename T2 = std::size_t>
void	quicksort (std::vector< T1 > &array, std::size_t beg, std::size_t end, std::vector< T2 > &perm)
template<typename T1, typename T2 = std::size_t>
void	quicksort (std::vector< T1 * > &array, std::size_t beg, std::size_t end, std::vector< T2 > &perm)
std::vector< std::string >	splitString (std::string const &str)
std::list< std::string >	splitString (const std::string &str, char delim)
std::string	replaceString (const std::string &searchString, const std::string &replaceString, std::string stringToReplace)
void	trim (std::string &str, char ch)
void	simplify (std::string &str)
std::string	format (const char *format_str,...)
std::string	randomString (std::size_t length)
	Returns a random string of the given length containing just a-z,A-Z,0-9.
std::string	getUniqueName (std::vector< std::string > const &existing_names, std::string const &input_name)
	Append '-' and a number such that the name is unique.
std::expected< int, std::string >	parseInteger (std::string_view const str)
template<typename T>
T	str2number (const std::string &str)
template<typename T>
std::optional< std::vector< T > >	tryParseVector (std::string const &raw, std::size_t *bad_token_idx)
std::string	defaultLogLevel ()
TCLAP::ValueArg< std::string >	makeLogLevelArg ()
template<typename T>
const char *	type_name ()
template<>
const char *	type_name< std::string > ()
template<>
const char *	type_name< int > ()
template<>
const char *	type_name< double > ()
template<>
const char *	type_name< float > ()
template<>
const char *	type_name< bool > ()
template<>
const char *	type_name< size_t > ()
template<>
const char *	type_name< long > ()
template<>
const char *	type_name< unsigned > ()

Variables
std::shared_ptr< spdlog::logger >	console

Function Documentation

◆ all_of()

template<typename List>

bool BaseLib::all_of ( List const & values )

constexpr

Checks if all of the elements in the given list are true.

Definition at line 327 of file Algorithm.h.

{
    // std::all_of is not constexpr enough in some STLs
    for (auto& value : values)
    {
        if (!static_cast<bool>(value))
        {
            return false;
        }
    }
 
    return true;
}

◆ any_of()

template<typename List>

bool BaseLib::any_of ( List const & values )

constexpr

Checks if any of the elements in the given list is true.

Definition at line 311 of file Algorithm.h.

{
    // std::any_of is not constexpr enough in some STLs
    for (auto& value : values)
    {
        if (static_cast<bool>(value))
        {
            return true;
        }
    }
 
    return false;
}

Referenced by BaseLib::TMP::contains(), and none_of().

◆ checkAndInvalidate() [1/3]

void BaseLib::checkAndInvalidate ( ConfigTree & conf )

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

Definition at line 535 of file ConfigTree.cpp.

{
    conf.checkAndInvalidate();
}

◆ checkAndInvalidate() [2/3]

void BaseLib::checkAndInvalidate ( ConfigTree *const conf )

Check if conf has been read entirely and invalidate it.

This method can safely be called on nullptr's.

See also: ConfigTree::checkAndInvalidate()

Definition at line 540 of file ConfigTree.cpp.

{
    if (conf)
    {
        conf->checkAndInvalidate();
    }
}

◆ checkAndInvalidate() [3/3]

void BaseLib::checkAndInvalidate ( std::unique_ptr< ConfigTree > const & conf )

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

Definition at line 548 of file ConfigTree.cpp.

{
    if (conf)
    {
        conf->checkAndInvalidate();
    }
}

◆ cleanupVectorElements() [1/2]

template<typename T>

void BaseLib::cleanupVectorElements ( std::vector< T * > & items )

Function to destruct objects stored in a container as pointers.

Definition at line 274 of file Algorithm.h.

{
    for (auto item : items)
    {
        delete item;
    }
    items.clear();
}

Referenced by GeoLib::GEOObjects::~GEOObjects(), FileIO::GMSH::GMSHInterface::~GMSHInterface(), FileIO::GMSH::GMSHPolygonTree::~GMSHPolygonTree(), cleanupVectorElements(), FileIO::SwmmInterface::convertSwmmInputToGeometry(), FileIO::Gocad::GocadAsciiReader::createMesh(), GeoLib::IO::XmlGmlInterface::readFile(), FileIO::GMSInterface::readMesh(), FileIO::TetGenInterface::readTetGenGeometry(), FileIO::TetGenInterface::readTetGenMesh(), and MeshToolsLib::MeshRevision::simplifyMesh().

◆ cleanupVectorElements() [2/2]

template<typename T1, typename... Args>

void BaseLib::cleanupVectorElements	(	std::vector< T1 * > &	dependent_items,
		Args &&...	args )

Util function to cleanup the memory of multiple containers containing pointers to objects. Sometimes, there are dependencies between the pointer items in the containers. For instance, a GeoLib::Polyline or a GeoLib::Surface depends on the GeoLib::Point pointers stored in a std::vector<GeoLib::Point*>. Then, the dependent items have to cleaned up before the GeoLib::Point objects are deleted. A similar relation exists between MeshLib::Element objects and MeshLib::Node objects.

Definition at line 291 of file Algorithm.h.

{
    cleanupVectorElements(dependent_items);
    cleanupVectorElements(std::forward<Args>(args)...);
}

References cleanupVectorElements().

◆ constructFormattedFileName()

std::string BaseLib::constructFormattedFileName	(	std::string const &	format_specification,
		std::string const &	mesh_name,
		int const	timestep,
		double const	t,
		int const	iteration,
		bool const	converged )

Definition at line 109 of file FileTools.cpp.

{
    char const open_char = '{';
    char const close_char = '}';
    std::string::size_type begin = 0;
    std::string::size_type end = std::string::npos;
    std::string result = format_specification;
 
    while (begin != std::string::npos)
    {
        auto length_before_substitution = result.length();
        // find next parenthesized string
        std::string str = "";
        std::tie(str, begin, end) =
            getParenthesizedString(result, open_char, close_char, begin);
        if (!substituteKeyword(result, str, begin, end, "timestep", timestep) &&
            !substituteKeyword(result, str, begin, end, "time", t) &&
            !substituteKeyword(result, str, begin, end, "iteration",
                               iteration) &&
            !substituteKeyword(result, str, begin, end, "converged", converged))
        {
            substituteKeyword(result, str, begin, end, "meshname", mesh_name);
        }
        begin = end - (length_before_substitution - result.length());
    }
 
    return result;
}

References getParenthesizedString(), and substituteKeyword().

Referenced by ProcessLib::OutputVTKFormat::constructFilename(), ProcessLib::OutputXDMFHDF5Format::constructFilename(), and ProcessLib::OutputVTKFormat::constructPVDName().

◆ containsKeyword()

std::string BaseLib::containsKeyword	(	std::string const &	str,
		std::string const &	keyword )

Definition at line 51 of file FileTools.cpp.

{
    auto const position = str.find(keyword);
    if (position != std::string::npos)
    {
        return str.substr(0, position);
    }
    return "";
}

Referenced by substituteKeyword().

◆ createOutputDirectory()

bool BaseLib::createOutputDirectory ( std::string const & dir )

Definition at line 221 of file FileTools.cpp.

{
    if (dir.empty())
    {
        return false;
    }
 
    std::error_code mkdir_err;
    if (std::filesystem::create_directories(dir, mkdir_err))
    {
        INFO("Output directory {:s} created.", dir);
    }
    else if (mkdir_err.value() != 0)
    {
        WARN("Could not create output directory {:s}. Error code {:d}, {:s}",
             dir, mkdir_err.value(), mkdir_err.message());
        return false;
    }
    return true;
}

References INFO(), and WARN().

Referenced by OGSSimulation::OGSSimulation(), and main().

◆ date2int()

int BaseLib::date2int	(	int	y,
		int	m,
		int	d )

Converts three integers representing a date into a double. Note: It is not really checked if the date actually makes sense.

Definition at line 15 of file DateTools.cpp.

{
    if ((y < 1000 || y > 9999) || (m < 1 || m > 12) || (d < 1 || d > 31))
    {
        WARN("date2int(): Input not in expected range.");
        return 0;
    }
 
    int ddate(0);
    ddate = y * 10000;
    ddate += (m * 100);
    ddate += d;
 
    return ddate;
}

References WARN().

Referenced by strDate2int(), and xmlDate2int().

◆ date2string()

std::string BaseLib::date2string ( double ddate )

Converts a double representing a date into a string. Note: It is not really checked if the date actually makes sense.

Parameters

ddate Number containing date in double format yyyymmdd

Returns: A string containing the date in format "dd.mm.yyyy".

Definition at line 54 of file DateTools.cpp.

{
    if (ddate < 10000101 || ddate > 99991231)
    {
        WARN("date2String(): Input not in expected format.");
        return "0.0.0000";
    }
 
    auto rest(static_cast<int>(ddate));
    auto y = static_cast<int>(std::floor(rest / 10000.0));
    rest = rest % (y * 10000);
    auto m = static_cast<int>(std::floor(rest / 100.0));
    if (m < 1 || m > 12)
    {
        WARN("date2String(): month not in [1:12].");
    }
    rest = rest % (m * 100);
    int d = rest;
    if (d < 1 || d > 31)
    {
        WARN("date2String(): day not in [1:31].");
    }
 
    std::string day = std::to_string(d);
    if (d < 10)
    {
        day = "0" + day;
    }
    std::string month = std::to_string(m);
    if (m < 10)
    {
        month = "0" + month;
    }
    std::string s = std::to_string(y) + "-" + month + "-" + day;
    return s;
}

References WARN().

Referenced by GeoLib::IO::XmlStnInterface::writeBoreholeData().

◆ defaultLogLevel()

std::string BaseLib::defaultLogLevel ( )

Definition at line 10 of file TCLAPArguments.cpp.

{
#ifdef NDEBUG
    return "info";
#else
    return "all";
#endif
}

Referenced by OGSSimulation::OGSSimulation(), and makeLogLevelArg().

◆ demangle()

std::string BaseLib::demangle ( const char * mangled_name )

Non-template helper function for demangling mangled type names. Converts a C++ ABI mangled name into a human-readable string. Uses C++ ABI demangling (GCC/Clang) or UnDecorateSymbolName (MSVC). Falls back to the mangled name if demangling fails. See https://gcc.gnu.org/onlinedocs/libstdc++/manual/ext_demangling.html for GCC/Clang details and https://learn.microsoft.com/en-us/windows/win32/api/dbghelp/nf-dbghelp-undecoratesymbolname for MSVC.

Definition at line 21 of file DemangleTypeInfo.cpp.

{
#ifdef _MSC_VER
    // MSVC demangling using UnDecorateSymbolName
    char demangled_buffer[1024] = {0};
    if (UnDecorateSymbolName(mangled_name, demangled_buffer,
                             sizeof(demangled_buffer), UNDNAME_COMPLETE))
    {
        return demangled_buffer;
    }
#else
    // GCC/Clang demangling using __cxa_demangle
    int status = 0;
    std::unique_ptr<char, decltype(&std::free)> demangled(
        abi::__cxa_demangle(mangled_name, nullptr, nullptr, &status),
        &std::free);
 
    if (status == 0 && demangled)
    {
        return demangled.get();
    }
#endif
 
    // Fallback to mangled name if demangling fails
    return mangled_name;
}

◆ dropFileExtension()

std::string BaseLib::dropFileExtension ( std::string const & filename )

Returns a string with file extension as found by getFileExtension() dropped.

Definition at line 165 of file FileTools.cpp.

{
    auto const filename_path = std::filesystem::path(filename);
    return (filename_path.parent_path() / filename_path.stem()).string();
}

Referenced by convert(), extractBaseNameWithoutExtension(), VtkRaster::findWorldFile(), identifyAndWriteBoundaryMeshes(), main(), FileIO::Gocad::GocadAsciiReader::readFile(), MeshLib::IO::readMeshFromFile(), writeCsvOutput(), and writeMeshOutput().

◆ excludeObjectCopy() [1/2]

template<typename T>

std::vector< T > BaseLib::excludeObjectCopy	(	std::vector< T > const &	src_vec,
		std::vector< std::size_t > const &	exclude_positions )

excludeObjectCopy copies only those objects that position within the source vector is not in the exclude_positions vector. The implementation of the algorithm requires that the given positions in exclude_positions are sorted in ascending order.

Parameters

src_vec	the vector of source objects
exclude_positions	the positions of objects in the source vector that do not have to be copied

Returns: vector that contains the copied objects

Definition at line 36 of file Algorithm.h.

{
    std::vector<T> dest_vec;
    if (exclude_positions.empty())
    {
        dest_vec = src_vec;
        return dest_vec;
    }
 
    assert(exclude_positions.back() < src_vec.size());
 
    std::copy_n(src_vec.cbegin(), exclude_positions[0],
                std::back_inserter(dest_vec));
    for (std::size_t i = 1; i < exclude_positions.size(); ++i)
    {
        std::copy_n(src_vec.cbegin() + exclude_positions[i - 1] + 1,
                    exclude_positions[i] - (exclude_positions[i - 1] + 1),
                    std::back_inserter(dest_vec));
    }
    std::copy(src_vec.cbegin() + exclude_positions.back() + 1, src_vec.cend(),
              std::back_inserter(dest_vec));
 
    return dest_vec;
}

Referenced by MeshLib::PropertyVector< PROP_VAL_TYPE >::clone(), excludeObjectCopy(), and MeshToolsLib::removeElements().

◆ excludeObjectCopy() [2/2]

template<typename T>

void BaseLib::excludeObjectCopy	(	std::vector< T > const &	src_vec,
		std::vector< std::size_t > const &	exclude_positions,
		std::vector< T > &	dest_vec )

Definition at line 64 of file Algorithm.h.

{
    dest_vec = excludeObjectCopy(src_vec, exclude_positions);
}

References excludeObjectCopy().

◆ extractBaseName()

std::string BaseLib::extractBaseName ( std::string const & pathname )

Extracts basename from given pathname with extension.

Returns a string containing everything after the last path separator. If the the pathname does not contain a path separator original pathname is returned.

Definition at line 171 of file FileTools.cpp.

{
    return std::filesystem::path(pathname).filename().string();
}

Referenced by OGSFileConverter::convertGLI2GML(), extractBaseNameWithoutExtension(), OGSFileConverter::fileExists(), MeshLib::IO::getVtuFileNameForPetscOutputWithoutExtension(), anonymous_namespace{postLIE.cpp}::postPVD(), FileIO::Legacy::readGLIFileV4(), and MeshLib::IO::NodePartitionedMeshReader::readMesh().

◆ extractBaseNameWithoutExtension()

std::string BaseLib::extractBaseNameWithoutExtension ( std::string const & pathname )

Extracts basename from given pathname without its extension.

Same as extractBaseName(), but drops the file extension too.

Definition at line 176 of file FileTools.cpp.

{
    std::string basename = extractBaseName(pathname);
    return dropFileExtension(basename);
}

References dropFileExtension(), and extractBaseName().

Referenced by FileIO::SwmmInterface::convertSwmmInputToGeometry(), anonymous_namespace{TestDefinition.cpp}::findDiffTool(), FileIO::Gocad::GocadSGridReader::getMesh(), MeshLib::IO::Legacy::MeshIO::loadMeshFromFile(), main(), FileIO::FEFLOWGeoInterface::readFEFLOWFile(), FileIO::FEFLOWMeshInterface::readFEFLOWFile(), FileIO::GMSH::readGMSHMesh(), FileIO::GMSInterface::readMesh(), FileIO::TetGenInterface::readTetGenGeometry(), FileIO::TetGenInterface::readTetGenMesh(), MeshLib::IO::VtuInterface::readVTKFile(), MeshLib::IO::VtuInterface::readVTUFile(), and writeGeoOutput().

◆ extractPath()

std::string BaseLib::extractPath ( std::string const & pathname )

Extracts the path of a pathname.

Returns a string up to the last path separator not including it.

Definition at line 192 of file FileTools.cpp.

{
    return std::filesystem::path(pathname).parent_path().string();
}

Referenced by MeshLib::IO::getVtuFileNameForPetscOutputWithoutExtension(), Simulation::initializeDataStructures(), main(), parseCommandLineArguments(), anonymous_namespace{postLIE.cpp}::postPVD(), readAndPatchPrj(), FileIO::Legacy::readGLIFileV4(), readVtuFileNames(), FileIO::Legacy::writeAllDataToGLIFileV4(), and FileIO::Legacy::writeGLIFileV4().

◆ findElementOrError()

template<ranges::input_range Range>

ranges::range_reference_t< Range > BaseLib::findElementOrError	(	Range &	range,
		std::predicate< ranges::range_reference_t< Range > > auto &&	predicate,
		std::invocable auto	error_callback )

Returns reference to an element in the range satisfying the predicate. If no such element is found, error_callback is called and reference to past-the-end of the range is returned.

Definition at line 75 of file Algorithm.h.

{
    auto it =
        ranges::find_if(range, std::forward<decltype(predicate)>(predicate));
    if (it == ranges::end(range))
    {
        error_callback();
        OGS_FATAL(
            "Element not found in the input range. The user provided error "
            "callback is meant not to return. That has not happened.");
    }
    return *it;
}

References OGS_FATAL.

Referenced by MaterialPropertyLib::Phase::component(), MeshLib::findMeshByName(), MaterialLib::Solids::MFront::MFrontGeneric< DisplacementDim, boost::mp11::mp_list< Strain >, boost::mp11::mp_list< Stress >, boost::mp11::mp_list< Temperature > >::initializeInternalStateVariables(), OGSMesh::meshItemType(), MaterialPropertyLib::Medium::phase(), and ChemistryLib::PhreeqcIOData::PhreeqcIO::updateChemicalSystemFromOutput().

◆ findFirstNotEqualElement()

template<typename Container>

std::optional< typename Container::value_type > BaseLib::findFirstNotEqualElement	(	Container const &	container,
		typename Container::value_type const &	element )

Definition at line 245 of file Algorithm.h.

{
    auto const it =
        std::find_if_not(container.begin(), container.end(),
                         [&element](typename Container::value_type const& e)
                         { return e == element; });
    return it == container.end() ? std::nullopt : std::make_optional(*it);
}

Referenced by ProcessLib::LIE::PostProcessTool::PostProcessTool().

◆ findIndex()

template<typename Container>

std::size_t BaseLib::findIndex	(	Container const &	container,
		typename Container::value_type const &	element )

Returns the index of first element in container or, if the element is not found a std::size_t maximum value.

The maximum value of std::size_t is chosen, because such an index cannot exist in a container; the maximum index is std::size_t::max-1.

Definition at line 261 of file Algorithm.h.

{
    auto const it = std::find(container.begin(), container.end(), element);
    if (it == container.end())
    {
        return std::numeric_limits<std::size_t>::max();
    }
    return std::distance(container.begin(), it);
}

Referenced by ProcessLib::LIE::PostProcessTool::PostProcessTool(), and ProcessLib::ComponentTransport::LookupTable::getTableEntryID().

◆ format()

std::string BaseLib::format	(	const char *	format_str,
			... )

Definition at line 77 of file StringTools.cpp.

{
    va_list args;
    va_start(args, format_str);
    // get the number of chars to write
    va_list args_tmp;
    va_copy(args_tmp, args);
    int char_length = std::vsnprintf(nullptr, 0, format_str, args_tmp);
    va_end(args_tmp);
    // allocate buffer and store formatted output there
    std::vector<char> buffer(char_length + 1);  // note +1 for null terminator
    vsnprintf(buffer.data(), buffer.size(), format_str, args);
    va_end(args);
 
    return std::string(buffer.data());
}

◆ formatDate()

std::string BaseLib::formatDate ( std::chrono::time_point< std::chrono::system_clock > const & time )

Formats the given time point according to RFC 3339 (cf. man-page of the unix date utility).

Example: 2006-08-14 02:34:56-06:00

Definition at line 126 of file DateTools.cpp.

{
    auto const time_t = std::chrono::system_clock::to_time_t(time);
    char time_str[100];
    if (std::strftime(time_str, sizeof(time_str), "%Y-%m-%d %H:%M:%S%z",
                      std::localtime(&time_t)))
    {
        return time_str;
    }
    return "FAILED FORMATTING THE GIVEN TIME POINT.";
}

Referenced by OGSSimulation::OGSSimulation(), OGSSimulation::executeSimulation(), initializeLogger(), main(), Simulation::runTestDefinitions(), and signalHandler().

◆ getDuplicates()

template<ranges::input_range Range>
requires std::totally_ordered<ranges::range_value_t<Range>> && std::copyable<ranges::range_value_t<Range>>

std::vector< ranges::range_value_t< Range > > BaseLib::getDuplicates ( Range && range )

Returns the elements occurring more than once in the range range, each of them reported once. The result is sorted ascendingly because the duplicates are collected in a std::set, which the elements are copied into. The returned vector is empty if all elements are pairwise different.

Definition at line 178 of file Algorithm.h.

{
    using Element = ranges::range_value_t<Range>;
 
    std::set<Element> seen;
    std::set<Element> duplicates;
    for (auto const& element : range)
    {
        if (!seen.insert(element).second)
        {
            duplicates.insert(element);
        }
    }
 
    return {duplicates.begin(), duplicates.end()};
}

Referenced by MeshLib::IntegrationPointMetaData::checkFieldNamesAreUnique(), ProcessLib::createSubmeshResiduumOutputConfig(), anonymous_namespace{CreateOutput.cpp}::getDuplicateOutputNames(), and anonymous_namespace{ProjectData.cpp}::readMeshes().

◆ getFileExtension()

std::string BaseLib::getFileExtension ( std::string const & path )

Extract extension from filename

Definition at line 182 of file FileTools.cpp.

{
    return std::filesystem::path(path).extension().string();
}

Referenced by VtkVisImageItem::callVTKWriter(), VtkVisPointSetItem::callVTKWriter(), convert(), MeshLib::IO::getVtuFileNameForPetscOutputWithoutExtension(), hasFileExtension(), identifyAndWriteBoundaryMeshes(), FileIO::SwmmInterface::isSwmmInputFile(), main(), readAndPatchPrj(), readDoublesFromBinaryFile(), FileIO::readGeometryFromFile(), FileIO::AsciiRasterInterface::readRaster(), FileIO::TetGenInterface::readTetGenGeometry(), writeCsvOutput(), FileIO::writeGeometryToFile(), and writeMeshOutput().

◆ getIfOrError()

template<typename Container, typename Predicate>

OGS_NO_DANGLING Container::value_type const & BaseLib::getIfOrError	(	Container const &	container,
		Predicate &&	predicate,
		std::string const &	error_message )

Returns the value of from the given container if such an entry fulfilling the predicate exists; otherwise an error_message is printed and the program is aborted.

Definition at line 157 of file Algorithm.h.

{
    auto it = std::find_if(begin(container), end(container), predicate);
    if (it == end(container))
    {
        OGS_FATAL("Could not find element matching the predicate: {:s}",
                  error_message);
    }
    return *it;
}

References OGS_FATAL, and OGS_NO_DANGLING.

Referenced by ProcessLib::createPerProcessData(), and ParameterLib::createRasterParameter().

◆ getNumberOfAssemblyThreads()

int BaseLib::getNumberOfAssemblyThreads ( )

Returns the number of threads to use for parallel assembly.

Returns: The number of threads set in OGS_ASM_THREADS environment variable or 1 if nothing is set.

Definition at line 67 of file OgsAsmThreads.cpp.

{
    return getNumberOfThreadsFromEnv("OGS_ASM_THREADS");
}

References getNumberOfThreadsFromEnv().

Referenced by getNumberOfChemistryThreads(), and getNumberOfThreads().

◆ getNumberOfChemistryThreads()

int BaseLib::getNumberOfChemistryThreads ( )

Returns the number of threads to use for parallel chemistry calculations. Priority: OGS_CHEM_THREADS env var, then OGS_ASM_THREADS env var, then 1.

Definition at line 12 of file OgsChemThreads.cpp.

{
    if (std::getenv("OGS_CHEM_THREADS"))
    {
        return getNumberOfThreadsFromEnv("OGS_CHEM_THREADS");
    }
    return getNumberOfAssemblyThreads();
}

References getNumberOfAssemblyThreads(), and getNumberOfThreadsFromEnv().

◆ getNumberOfThreads()

int BaseLib::getNumberOfThreads ( )

Returns the maximum of getNumberOfAssemblyThreads() and omp_get_max_threads().

Definition at line 72 of file OgsAsmThreads.cpp.

{
#ifdef _OPENMP
    int const num_omp_threads = omp_get_max_threads();
#else
    int const num_omp_threads = 1;
#endif
    return std::max(getNumberOfAssemblyThreads(), num_omp_threads);
}

References getNumberOfAssemblyThreads().

Referenced by MaterialPropertyLib::Function::Function().

◆ getNumberOfThreadsFromEnv()

int BaseLib::getNumberOfThreadsFromEnv ( char const * env_var_name )

Reads the integer value from the given environment variable and returns it. Returns 1 if the variable is unset. Calls OGS_FATAL if the variable is set but empty, cannot be parsed as an integer, or its value is less than 1.

Definition at line 19 of file OgsAsmThreads.cpp.

{
    char const* const num_threads_env = std::getenv(env_var_name);
 
    if (!num_threads_env)
    {
        return 1;
    }
 
    if (std::strlen(num_threads_env) == 0)
    {
        OGS_FATAL("The environment variable {} is set but empty.",
                  env_var_name);
    }
 
    std::string num_threads_str{num_threads_env};
    BaseLib::trim(num_threads_str);
 
    std::istringstream num_threads_iss{num_threads_str};
    int num_threads = -1;
 
    num_threads_iss >> num_threads;
 
    if (!num_threads_iss)
    {
        OGS_FATAL("Error parsing {} (= \"{}\").", env_var_name,
                  num_threads_env);
    }
 
    if (!num_threads_iss.eof())
    {
        OGS_FATAL(
            "Error parsing {} (= \"{}\"): not read entirely, the "
            "remainder is \"{}\"",
            env_var_name,
            num_threads_env,
            num_threads_iss.str().substr(num_threads_iss.tellg()));
    }
 
    if (num_threads < 1)
    {
        OGS_FATAL("You asked (via {}) to use {} < 1 thread.", env_var_name,
                  num_threads);
    }
 
    return num_threads;
}

References OGS_FATAL, and trim().

Referenced by getNumberOfAssemblyThreads(), and getNumberOfChemistryThreads().

◆ getOrError() [1/2]

template<typename Map, typename Key>

OGS_NO_DANGLING Map::mapped_type & BaseLib::getOrError	(	Map &	map,
		Key const &	key,
		std::string const &	error_message )

Returns the value of key from the given map if such an entry exists; otherwise an error_message is printed and the program is aborted. Cf. also the const overload below.

Definition at line 112 of file Algorithm.h.

{
    auto it = map.find(key);
    if (it == map.end())
    {
        if constexpr (std::is_convertible<Key, std::string>::value)
        {
            OGS_FATAL("{:s} Key `{:s}' does not exist.", error_message, key);
        }
        else
        {
            OGS_FATAL("{:s} Key `{:s}' does not exist.", error_message,
                      std::to_string(key));
        }
    }
 
    return it->second;
}

References OGS_FATAL, and OGS_NO_DANGLING.

Referenced by MaterialPropertyLib::createCurve(), ProcessLib::HeatTransportBHE::BHE::createFlowAndTemperatureControl(), ProcessLib::createPerProcessData(), ProcessLib::HeatTransportBHE::BHE::createPowerWithCOPStruct(), MaterialPropertyLib::createSaturationWeightedThermalConductivity(), anonymous_namespace{SubmeshResiduumOutputConfig.cpp}::filterMeshesForResiduumOutput(), ProjectData::parseNonlinearSolvers(), and ProcessLib::parseTimeIntervalOrCurve().

◆ getOrError() [2/2]

template<typename Map, typename Key>

OGS_NO_DANGLING Map::mapped_type const & BaseLib::getOrError	(	Map const &	map,
		Key const &	key,
		std::string const &	error_message )

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

Definition at line 133 of file Algorithm.h.

{
    auto it = map.find(key);
    if (it == map.end())
    {
        if constexpr (std::is_convertible<Key, std::string>::value)
        {
            OGS_FATAL("{:s} Key `{:s}' does not exist.", error_message, key);
        }
        else
        {
            OGS_FATAL("{:s} Key `{:s}' does not exist.", error_message,
                      std::to_string(key));
        }
    }
 
    return it->second;
}

References OGS_FATAL, and OGS_NO_DANGLING.

◆ getParenthesizedString()

std::tuple< std::string, std::string::size_type, std::string::size_type > BaseLib::getParenthesizedString	(	std::string const &	in,
		char const	open_char,
		char const	close_char,
		std::string::size_type	pos )

Returns the begin and end position of the string enclosed in open_char and close_char and the enclosed string itself. Search starts at position pos within the string str. Nested open_char and close_char are not handled correctly.

Definition at line 29 of file FileTools.cpp.

{
    auto const pos_curly_brace_open = in.find_first_of(open_char, pos);
    if (pos_curly_brace_open == std::string::npos)
    {
        return std::make_tuple("", std::string::npos, std::string::npos);
    }
    auto const pos_curly_brace_close =
        in.find_first_of(close_char, pos_curly_brace_open);
    if (pos_curly_brace_close == std::string::npos)
    {
        return std::make_tuple("", std::string::npos, std::string::npos);
    }
    return std::make_tuple(
        in.substr(pos_curly_brace_open + 1,
                  pos_curly_brace_close - (pos_curly_brace_open + 1)),
        pos_curly_brace_open, pos_curly_brace_close);
}

Referenced by constructFormattedFileName().

◆ getUniqueName()

std::string BaseLib::getUniqueName	(	std::vector< std::string > const &	existing_names,
		std::string const &	input_name )

Append '-' and a number such that the name is unique.

Definition at line 112 of file StringTools.cpp.

{
    std::string result_name = input_name;
    std::size_t count = 1;
    while (std::find(existing_names.cbegin(),
                     existing_names.cend(),
                     result_name) != existing_names.end())
    {
        count++;
        result_name = input_name + "-" + std::to_string(count);
    }
    return result_name;
}

Referenced by ParameterLib::getNamedOrCreateInlineParameter(), GeoLib::GEOObjects::isUniquePointVecName(), and MeshToolsLib::RasterDataToMesh::projectToMeshItems().

◆ hasFileExtension()

bool BaseLib::hasFileExtension	(	std::string const &	extension,
		std::string const &	filename )

Compares filename's extension with query extension. The comparison is case insensitive.

Definition at line 187 of file FileTools.cpp.

{
    return boost::iequals(extension, getFileExtension(filename));
}

References getFileExtension().

Referenced by main(), and anonymous_namespace{readMeshFromFile.cpp}::readMeshFromFileSerial().

◆ initOGSLogger()

void BaseLib::initOGSLogger ( std::string const & log_level )

Definition at line 104 of file Logging.cpp.

{
    if (!console)
    {
#if defined(_WIN32) && defined(OGS_BUILD_WHEEL)
        // Custom sink re-resolving stdout per write; see Fd1StdoutSink above.
        // No colour on Windows console as a consequence.
#if defined(USE_PETSC) || defined(_OPENMP)
        console = std::make_shared<spdlog::logger>(
            "ogs", std::make_shared<Fd1StdoutSink<std::mutex>>());
#else
        console = std::make_shared<spdlog::logger>(
            "ogs",
            std::make_shared<Fd1StdoutSink<spdlog::details::null_mutex>>());
#endif
        spdlog::register_logger(console);
#else
#if defined(USE_PETSC) || defined(_OPENMP)
        // Thread-safe sink is required when OGS logs concurrently, e.g. from
        // OpenMP assembly threads. Otherwise the non-thread-safe sink races and
        // may corrupt output (e.g. console output interleaved into other
        // files).
        console = spdlog::stdout_color_mt("ogs");
#else
        console = spdlog::stdout_color_st("ogs");
#endif
#endif  // defined(_WIN32) && defined(OGS_BUILD_WHEEL)
        // Default pattern and error handler both for MPI and non-MPI builds.
        spdlog::set_pattern("%^%l:%$ %v");
        spdlog::set_error_handler(error_handler);
 
#ifdef USE_PETSC
        int mpi_init;
        MPI_Initialized(&mpi_init);
        if (mpi_init == 1)
        {
            MPI_Comm_rank(BaseLib::MPI::OGS_COMM_WORLD, &mpi_rank);
            spdlog::set_pattern(fmt::format("[{}] %^%l:%$ %v", mpi_rank));
            spdlog::set_error_handler(mpi_error_handler);
        }
#endif  // USE_PETSC
    }
    BaseLib::setConsoleLogLevel(log_level);
}

References console, BaseLib::MPI::OGS_COMM_WORLD, and setConsoleLogLevel().

Referenced by OGSSimulation::OGSSimulation(), main(), main(), PYBIND11_MODULE(), PYBIND11_MODULE(), and PYBIND11_MODULE().

◆ insertIfKeyUniqueElseError()

template<typename Map, typename Key, typename Value>

void BaseLib::insertIfKeyUniqueElseError	(	Map &	map,
		Key const &	key,
		Value &&	value,
		std::string const &	error_message )

Inserts the given key with the given value into the map if an entry with the given key does not yet exist; otherwise an error_message is printed and the program is aborted.

Definition at line 98 of file Algorithm.h.

{
    auto const inserted = map.emplace(key, std::forward<Value>(value));
    if (!inserted.second)
    {  // insertion failed, i.e., key already exists
        OGS_FATAL("{} Key `{}' already exists.", error_message, key);
    }
}

References OGS_FATAL.

Referenced by ProcessLib::SecondaryVariableCollection::addNameMapping(), ProjectData::parseCurves(), ProjectData::parseLinearSolvers(), ProjectData::parseNonlinearSolvers(), GeoLib::IO::BoostXmlGmlInterface::readPoints(), GeoLib::IO::BoostXmlGmlInterface::readPolylines(), and GeoLib::IO::BoostXmlGmlInterface::readSurfaces().

◆ int2date()

std::string BaseLib::int2date ( int date )

Converts an integer to a string date "dd.mm.yyyy" Note: (Almost) no checks are performed if the int makes sense as a date.

Definition at line 31 of file DateTools.cpp.

{
    if (date > 10000000 && date < 22000000)
    {
        auto y = static_cast<int>(std::floor(date / 10000.0));
        auto m = static_cast<int>(std::floor((date - (y * 10000)) / 100.0));
        int d = date - (y * 10000) - (m * 100);
        std::stringstream ss;
        if (d < 10)
        {
            ss << "0";
        }
        ss << d << ".";
        if (m < 10)
        {
            ss << "0";
        }
        ss << m << "." << y;
        return ss.str();
    }
    return "";
}

Referenced by DiagramList::readList().

◆ IsFileExisting()

bool BaseLib::IsFileExisting ( const std::string & strFilename )

Returns true if given file exists.

Parameters

strFilename the file name

Definition at line 23 of file FileTools.cpp.

{
    return std::filesystem::exists(std::filesystem::path(strFilename));
}

Referenced by ChemistryLib::createChemicalSolverInterface< ChemicalSolver::Phreeqc >(), ProcessLib::ComponentTransport::createLookupTable(), anonymous_namespace{TestDefinition.cpp}::findDiffTool(), anonymous_namespace{postLIE.cpp}::postPVD(), MeshLib::IO::NodePartitionedMeshReader::read(), readAndPatchPrj(), readBinaryVector(), anonymous_namespace{ProjectData.cpp}::readGeometry(), MeshLib::IO::VtuInterface::readVTKFile(), and MeshLib::IO::VtuInterface::readVtuFileToVtkUnstructuredGrid().

◆ joinPaths()

std::string BaseLib::joinPaths	(	std::string const &	pathA,
		std::string const &	pathB )

Concat two paths. Does not check for validity.

Definition at line 197 of file FileTools.cpp.

{
    return (std::filesystem::path(pathA) /= std::filesystem::path(pathB))
        .string();
}

Referenced by ApplicationsLib::TestDefinition::TestDefinition(), ProcessLib::OutputVTKFormat::constructPVDName(), ChemistryLib::createChemicalSolverInterface< ChemicalSolver::Phreeqc >(), ProcessLib::ComponentTransport::createLookupTable(), MaterialLib::Solids::MFront::createMFrontConfig(), ProcessLib::Output::doOutputNonlinearIteration(), anonymous_namespace{TestDefinition.cpp}::findDiffTool(), MeshLib::IO::getVtuFileNameForPetscOutputWithoutExtension(), main(), ProcessLib::outputMeshVtk(), ProcessLib::OutputXDMFHDF5Format::outputMeshXdmf(), anonymous_namespace{postLIE.cpp}::postPVD(), readAndPatchPrj(), readDoublesFromBinaryFile(), anonymous_namespace{ProjectData.cpp}::readGeometry(), FileIO::Legacy::readPolyline(), FileIO::Legacy::readPolylinePointVector(), anonymous_namespace{ProjectData.cpp}::readSingleMesh(), GeoLib::IO::XmlStnInterface::readStations(), FileIO::Legacy::readSurface(), readVtuFileNames(), and FileIO::Legacy::writeTINSurfaces().

◆ makeConfigTree()

ConfigTree BaseLib::makeConfigTree	(	std::string const &	filepath,
		bool const	be_ruthless,
		std::string const &	toplevel_tag,
		std::stringstream &	prj_stream )

Create a ConfigTree from an XML file.

Parameters

filepath	see ConfigTreeTopLevel::ConfigTreeTopLevel()
be_ruthless	see ConfigTreeTopLevel::ConfigTreeTopLevel()
toplevel_tag	name of the outermost tag in the XML file. The returned ConfigTree is rooted one level below that tag.
prj_stream	content of the (pre-processed) prj file.

The parameter toplevel_tag is provided for compatibility with our existing configuration files whose toplevel tags are written in camel case, which conflicts with the naming rules of ConfigTree. Via that parameter the naming rules do not apply to the toplevel tag.

Unfortunately the XML parser shipped with boost::property_tree does not fully support the XML standard. Additionally there might be encoding issues. From their docs:

Please note that RapidXML does not understand the encoding specification. If you pass it a > character buffer, it assumes the data is already correctly encoded; if you pass it a filename, > it will read the file using the character conversion of the locale you give it (or the global > locale if you give it none). This means that, in order to parse a UTF-8-encoded XML file into > a wptree, you have to supply an alternate locale, either directly or by replacing the global one.

See also: http://www.boost.org/doc/libs/1_60_0/doc/html/property_tree/parsers.html

Definition at line 17 of file ConfigTreeUtil.cpp.

{
    ConfigTree::PTree ptree;
 
    // note: Trimming whitespace and ignoring comments is crucial in order
    //       for our configuration tree implementation to work!
    try
    {
        read_xml(prj_stream, ptree,
                 boost::property_tree::xml_parser::no_comments |
                     boost::property_tree::xml_parser::trim_whitespace);
    }
    catch (boost::property_tree::xml_parser_error const& e)
    {
        OGS_FATAL("Error while parsing XML file `{:s}' at line {:d}: {:s}.",
                  e.filename(), e.line(), e.message());
    }
 
    DBUG("Project configuration from file '{:s}' read.", filepath);
 
    if (auto opt_child = ptree.get_child_optional(toplevel_tag))
    {
        auto const callback =
            be_ruthless ? ConfigTree::onerror : ConfigTree::onwarning;
 
        return ConfigTree(std::move(*opt_child), filepath, callback, callback);
    }
    OGS_FATAL("Tag <{:s}> has not been found in file `{:s}'.", toplevel_tag,
              filepath);
}

References DBUG(), OGS_FATAL, BaseLib::ConfigTree::onerror(), and BaseLib::ConfigTree::onwarning().

Referenced by Simulation::initializeDataStructures(), and makeConfigTreeFromFile().

◆ makeConfigTreeFromFile()

ConfigTree BaseLib::makeConfigTreeFromFile	(	const std::string &	filepath,
		const bool	be_ruthless,
		const std::string &	toplevel_tag )

Definition at line 50 of file ConfigTreeUtil.cpp.

{
    std::ifstream file(filepath);
    if (file)
    {
        std::stringstream buffer;
        buffer << file.rdbuf();
 
        return makeConfigTree(filepath, be_ruthless, toplevel_tag, buffer);
    }
 
    OGS_FATAL("Could not read from file {:s}!", filepath);
}

References makeConfigTree(), and OGS_FATAL.

Referenced by GeoLib::IO::BoostXmlGmlInterface::readFile().

◆ makeLogLevelArg()

TCLAP::ValueArg< std::string > BaseLib::makeLogLevelArg ( )

Definition at line 19 of file TCLAPArguments.cpp.

{
    static std::vector<std::string> allowed_log_levels{"none", "error", "warn",
                                                       "info", "debug", "all"};
    static auto* allowed_log_levels_vals =
        new TCLAP::ValuesConstraint<std::string>(allowed_log_levels);
 
    return TCLAP::ValueArg<std::string>(
        "l", "log-level", "the verbosity of logging messages", false,
        defaultLogLevel(), allowed_log_levels_vals);
}

References defaultLogLevel().

Referenced by main(), main(), and parseCommandLineArguments().

◆ makeVectorUnique() [1/2]

template<typename T>

void BaseLib::makeVectorUnique ( std::vector< T > & v )

Make the entries of the std::vector v unique. The remaining entries will be sorted.

Definition at line 198 of file Algorithm.h.

{
    std::sort(v.begin(), v.end());
    auto it = std::unique(v.begin(), v.end());
    v.erase(it, v.end());
}

Referenced by ProcessLib::calculateUniqueFixedTimesForAllOutputs(), ParameterLib::collectVariables(), ProcessLib::ComponentTransport::createLookupTable(), ProcessLib::createOutputConfig(), ProcessLib::LIE::anonymous_namespace{MeshUtils.cpp}::findFracutreIntersections(), ProcessLib::findProcessVariables(), MeshLib::getBaseNodes(), ProcessLib::HeatTransportBHE::getBHEDataInMesh(), MeshGeoToolsLib::getCandidateElementsForLineSegmentIntersection(), ProcessLib::LIE::getFractureMatrixDataInMesh(), MeshGeoToolsLib::mapLineSegment(), reorderNonlinearNodes(), and MeshLib::ElementSearch::searchByNodeIDs().

◆ makeVectorUnique() [2/2]

template<typename T, class Compare>

void BaseLib::makeVectorUnique	(	std::vector< T > &	v,
		Compare	comp )

Make the entries of the std::vector v unique using the given binary function. The remaining entries will be sorted.

Definition at line 208 of file Algorithm.h.

{
    std::sort(v.begin(), v.end(), comp);
    auto it = std::unique(v.begin(), v.end());
    v.erase(it, v.end());
}

◆ none_of()

template<typename List>

bool BaseLib::none_of ( List const & values )

constexpr

Checks if none of the elements in the given list are true.

Definition at line 343 of file Algorithm.h.

{
    return !any_of(values);
}

References any_of().

◆ operator<<() [1/2]

template std::ostream & BaseLib::operator<<	(	std::ostream &	os,
		const Histogram< double > &	h )

◆ operator<<() [2/2]

template<typename T>

std::ostream & BaseLib::operator<<	(	std::ostream &	os,
		const Histogram< T > &	h )

Writes histogram to output stream.

Writes histogram properties in this order: number of bins, minimum, maximum, bin0 count, ..., binN-1 count.

Definition at line 70 of file Histogram.cpp.

{
    os << h.getNumberOfBins() << " " << h.getMinimum() << " " << h.getMaximum()
       << " ";
    std::copy(h.getBinCounts().begin(), h.getBinCounts().end(),
              std::ostream_iterator<std::size_t>(os, " "));
    return os << std::endl;
}

References BaseLib::Histogram< T >::getBinCounts(), BaseLib::Histogram< T >::getMaximum(), BaseLib::Histogram< T >::getMinimum(), and BaseLib::Histogram< T >::getNumberOfBins().

◆ parseInteger()

std::expected< int, std::string > BaseLib::parseInteger ( std::string_view str )

Parses a trimmed string as an integer. Returns the value, or an error message string on invalid input.

Definition at line 126 of file StringTools.cpp.

{
    int result = 0;
    auto const [ptr, ec] =
        std::from_chars(str.data(), str.data() + str.size(), result);
 
    if (ec == std::errc::invalid_argument)
    {
        return std::unexpected(
            fmt::format("Could not parse '{}' to a valid integer.", str));
    }
    if (ec == std::errc::result_out_of_range)
    {
        return std::unexpected(fmt::format(
            "Could not parse '{}'. The integer value exceeds the permitted "
            "range.",
            str));
    }
 
    std::size_t const chars_consumed = std::distance(str.data(), ptr);
    if (chars_consumed != str.size())
    {
        auto const non_ws_it = std::find_if_not(
            str.begin() + chars_consumed, str.end(),
            [](unsigned char const c) { return std::isspace(c); });
        if (non_ws_it != str.end())
        {
            return std::unexpected(fmt::format(
                "Could not parse '{}'. Invalid character: '{}' at position {}.",
                str, *non_ws_it, std::distance(str.begin(), non_ws_it)));
        }
    }
 
    return result;
}

Referenced by MaterialLib::splitMaterialIdString().

◆ patchStream()

void BaseLib::patchStream	(	std::string const &	patch_file,
		std::stringstream &	prj_stream,
		bool	after_includes = false )

Definition at line 171 of file PrjProcessing.cpp.

{
    // xmlReadFile(patch_file.c_str(), nullptr, 0); leads to malloc errors in
    // xmlFreeDoc(doc) below
    auto patch = xmlParseFile(patch_file.c_str());
    if (patch == nullptr)
    {
        OGS_FATAL("Error reading XML diff file {:s}.", patch_file);
    }
 
    auto doc = xmlReadMemory(prj_stream.str().c_str(), prj_stream.str().size(),
                             nullptr, nullptr, 0);
    if (doc == nullptr)
    {
        OGS_FATAL("Error reading project file from memory.");
    }
 
    auto node = xmlDocGetRootElement(patch);
    int rc = 0;
    for (node = node ? node->children : nullptr; node; node = node->next)
    {
        if (node->type != XML_ELEMENT_NODE)
        {
            continue;
        }
        bool node_after_includes = false;
        xmlAttr* attribute = node->properties;
        while (attribute)
        {
            // Check for after_includes-attribute
            xmlChar* value =
                xmlNodeListGetString(node->doc, attribute->children, 1);
            if (xmlStrEqual(attribute->name, xmlCharStrdup("after_includes")) &&
                xmlStrEqual(value, xmlCharStrdup("true")))
            {
                node_after_includes = true;
            }
 
            xmlFree(value);
            attribute = attribute->next;
        }
 
        if (after_includes != node_after_includes)
        {
            continue;
        }
 
        if (xmlStrEqual(node->name, xmlCharStrdup("add")))
        {
            rc = xml_patch_add(doc, node);
        }
        else if (xmlStrEqual(node->name, xmlCharStrdup("replace")))
        {
            rc = xml_patch_replace(doc, node);
        }
        else if (xmlStrEqual(node->name, xmlCharStrdup("remove")))
        {
            rc = xml_patch_remove(doc, node);
        }
        else
        {
            OGS_FATAL(
                "Error while patching prj file with patch file {:}. Only "
                "'add', 'replace' and 'remove' elements are allowed! Got an "
                "element '{:s}' on line {:d}.",
                patch_file, reinterpret_cast<const char*>(node->name),
                node->line);
        }
 
        if (rc)
        {
            OGS_FATAL(
                "Error while patching prj file with patch file {:}. Error in "
                "element '{:s}' on line {:d}.",
                patch_file, reinterpret_cast<const char*>(node->name),
                node->line);
        }
    }
 
    xmlChar* xmlbuff;
    int buffersize;
    xmlDocDumpMemory(doc, &xmlbuff, &buffersize);
    prj_stream.str("");  // Empty stream
    prj_stream << xmlbuff;
 
    xmlFree(xmlbuff);
    xmlFreeDoc(doc);
    xmlFreeDoc(patch);
}

References OGS_FATAL.

Referenced by prepareProjectFile(), and readAndPatchPrj().

◆ prepareProjectFile()

void BaseLib::prepareProjectFile	(	std::stringstream &	prj_stream,
		const std::string &	filepath,
		const std::vector< std::string > &	patch_files,
		bool	write_prj,
		const std::string &	out_directory )

Applies includes and patch files to project file.

Parameters

prj_stream	The processed prj as a stringstream.
filepath	The prj file.
patch_files	Optional patch files.
write_prj	Write the processed project file to disk?
out_directory	The directory to write the processed file to.

Definition at line 317 of file PrjProcessing.cpp.

{
    std::string prj_file = filepath;
 
    std::vector<std::string> patch_files_copy = patch_files;
    readAndPatchPrj(prj_stream, prj_file, patch_files_copy);
    replaceIncludes(prj_stream,
                    std::filesystem::absolute(std::filesystem::path(prj_file))
                        .parent_path());
    // re-apply xml patches to stream
    for (const auto& patch_file : patch_files_copy)
    {
        patchStream(patch_file, prj_stream, true);
    }
 
    if (write_prj)
    {
        // The following two lines should set indenting to 4 spaces but it does
        // not work. 2 spaces are default.
        //
        // xmlThrDefIndentTreeOutput(1);
        // xmlThrDefTreeIndentString("    "); // 4 spaces indent
        // XML_PARSE_NOBLANKS -> pretty-print
        auto doc =
            xmlReadMemory(prj_stream.str().c_str(), prj_stream.str().size(),
                          nullptr, nullptr, XML_PARSE_NOBLANKS);
        auto prj_out = (std::filesystem::path(out_directory) /
                        std::filesystem::path(filepath).stem())
                           .string() +
                       "_processed.prj";
        xmlSaveFormatFileEnc(prj_out.c_str(), doc, "utf-8", 1);
        INFO("Processed project file written to {:s}.", prj_out);
        xmlFreeDoc(doc);
    }
    xmlCleanupParser();
}

References INFO(), patchStream(), readAndPatchPrj(), and replaceIncludes().

Referenced by Simulation::initializeDataStructures().

◆ quicksort() [1/5]

template<typename It1, typename It2>

void BaseLib::quicksort	(	It1	first1,
		It1	last1,
		It2	first2 )

Precondition: {first1 <= last1 and the second iterator can be incremented distance(first1, last1) times}

Definition at line 43 of file quicksort.h.

{
    using T1 = typename std::iterator_traits<It1>::value_type;
    using T2 = typename std::iterator_traits<It2>::value_type;
 
    quicksort(first1, last1, first2,
              [](std::pair<T1, T2> const& a, std::pair<T1, T2> const& b)
              { return a.first < b.first; });
}

References quicksort().

◆ quicksort() [2/5]

template<typename It1, typename It2, typename Comparator>

void BaseLib::quicksort	(	It1	first1,
		It1	last1,
		It2	first2,
		Comparator	compare )

Precondition: {first1 <= last1 and the second iterator can be incremented distance(first1, last1) times}

Definition at line 17 of file quicksort.h.

{
    using T1 = typename std::iterator_traits<It1>::value_type;
    using T2 = typename std::iterator_traits<It2>::value_type;
 
    std::vector<std::pair<T1, T2>> data;
    data.reserve(std::distance(first1, last1));
    std::transform(first1, last1, first2, std::back_inserter(data),
                   [](T1 const& t1, T2 const& t2)
                   { return std::make_pair(t1, t2); });
 
    // Sort data using first element of the pair.
    std::sort(begin(data), end(data), compare);
 
    // Unzip sorted data.
    for (auto const& pair : data)
    {
        *first1 = pair.first;
        *first2 = pair.second;
        ++first1;
        ++first2;
    }
}

Referenced by MeshGeoToolsLib::MeshNodesAlongPolyline::MeshNodesAlongPolyline(), MathLib::PiecewiseLinearInterpolation::PiecewiseLinearInterpolation(), MathLib::PiecewiseLinearInterpolation::PiecewiseLinearInterpolation(), quicksort(), quicksort(), quicksort(), and GeoLib::Polygon::splitPolygonAtPoint().

◆ quicksort() [3/5]

template<typename T1, typename T2 = std::size_t>

void BaseLib::quicksort	(	std::vector< T1 * > &	array,
		std::size_t	beg,
		std::size_t	end,
		std::vector< T2 > &	perm )

Definition at line 74 of file quicksort.h.

{
    assert(beg <= end);
    assert(end <= array.size());
    assert(perm.size() == array.size());
 
    // Zip input arrays.
    std::vector<std::pair<T1*, T2>> data;
    data.reserve(end - beg);
    std::transform(array.begin() + beg, array.begin() + end, perm.begin() + beg,
                   std::back_inserter(data),
                   [](T1* const& t1, T2 const& t2)
                   { return std::make_pair(t1, t2); });
 
    // Sort data using first element of the pair.
    std::sort(data.begin(), data.end(),
              [](std::pair<T1*, T2> const& a, std::pair<T1*, T2> const& b)
              { return (*a.first < *b.first); });
 
    // Unzip sorted data.
    for (std::size_t i = 0; i < data.size(); i++)
    {
        array[beg + i] = data[i].first;
        perm[beg + i] = data[i].second;
    }
}

◆ quicksort() [4/5]

template<typename T1, typename T2 = std::size_t>

void BaseLib::quicksort	(	std::vector< T1 > &	array,
		std::size_t	beg,
		std::size_t	end,
		std::vector< T2 > &	perm )

Definition at line 63 of file quicksort.h.

{
    assert(beg <= end);
    assert(end <= array.size());
    assert(perm.size() == array.size());
 
    quicksort(array.data(), beg, end, perm.data());
}

References quicksort().

◆ quicksort() [5/5]

template<typename T1, typename T2 = std::size_t>

void BaseLib::quicksort	(	T1 *	array,
		std::size_t	beg,
		std::size_t	end,
		T2 *	perm )

Precondition: {end<=array.size() and perm.size()==array.size()}

Definition at line 55 of file quicksort.h.

{
    assert(beg <= end);
 
    quicksort(array + beg, array + end, perm + beg);
}

References quicksort().

◆ randomString()

std::string BaseLib::randomString ( std::size_t const length )

Returns a random string of the given length containing just a-z,A-Z,0-9.

Definition at line 94 of file StringTools.cpp.

{
    static constexpr char charset[] =
        "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
 
    static const auto seed = static_cast<std::mt19937::result_type>(
        std::chrono::system_clock::now().time_since_epoch().count());
    static std::mt19937 generator{seed};
    static std::uniform_int_distribution<unsigned short> distribution(
        0, sizeof(charset) - 2);
 
    std::string s(length, 0);
    std::generate_n(begin(s), length,
                    [&]() { return charset[distribution(generator)]; });
 
    return s;
}

Referenced by FileIO::createSurface().

◆ readAndPatchPrj()

void BaseLib::readAndPatchPrj	(	std::stringstream &	prj_stream,
		std::string &	prj_file,
		std::vector< std::string > &	patch_files )

Definition at line 264 of file PrjProcessing.cpp.

{
    // Extract base project file path if an xml (patch) file is given as prj
    // file and it contains the base_file attribute.
    if (BaseLib::getFileExtension(prj_file) == ".xml")
    {
        if (!patch_files.empty())
        {
            OGS_FATAL(
                "It is not allowed to specify additional patch files "
                "if a patch file was already specified as the "
                "prj-file.");
        }
        auto patch = xmlReadFile(prj_file.c_str(), nullptr, 0);
        auto node = xmlDocGetRootElement(patch);
        xmlChar const base_file_string[] = "base_file";
        auto base_file = xmlGetProp(node, base_file_string);
        if (base_file == nullptr)
        {
            OGS_FATAL(
                "Error reading base prj file (base_file attribute) in given "
                "patch file {:s}.",
                prj_file);
        }
        patch_files = {prj_file};
        std::stringstream ss;
        ss << base_file;
        prj_file = BaseLib::joinPaths(BaseLib::extractPath(prj_file), ss.str());
    }
 
    // read base prj file into stream
    if (std::ifstream file(prj_file); file)
    {
        prj_stream << file.rdbuf();
    }
    else
    {
        if (!BaseLib::IsFileExisting(prj_file))
        {
            ERR("File {:s} does not exist.", prj_file);
        }
        DBUG("Stream state flags: {:s}.", iostateToString(file.rdstate()));
        OGS_FATAL("Could not open project file '{:s}' for reading.", prj_file);
    }
 
    // apply xml patches to stream
    for (const auto& patch_file : patch_files)
    {
        patchStream(patch_file, prj_stream);
    }
}

References DBUG(), ERR(), extractPath(), getFileExtension(), IsFileExisting(), joinPaths(), OGS_FATAL, and patchStream().

Referenced by prepareProjectFile().

◆ readBinaryValue()

template<typename T>

T BaseLib::readBinaryValue ( std::istream & in )

Definition at line 258 of file FileTools.cpp.

{
    T v;
    in.read(reinterpret_cast<char*>(&v), sizeof(T));
    return v;
}

Referenced by FileIO::Gocad::GocadSGridReader::readNodesBinary().

◆ readBinaryValue< double >()

template double BaseLib::readBinaryValue< double > ( std::istream & )

◆ readBinaryValue< float >()

template float BaseLib::readBinaryValue< float > ( std::istream & )

◆ readBinaryVector()

template<typename T>

std::vector< T > BaseLib::readBinaryVector	(	std::string const &	filename,
		std::size_t const	start_element,
		std::size_t const	num_elements )

Definition at line 270 of file FileTools.cpp.

{
    if (!IsFileExisting(filename))
    {
        OGS_FATAL("File {:s} not found", filename);
    }
 
    // Determine file size
    std::uintmax_t file_size = std::filesystem::file_size(filename);
    std::size_t total_elements = file_size / sizeof(T);
 
    if (start_element >= total_elements)
    {
        OGS_FATAL("Start element is beyond file size");
    }
 
    // Calculate the number of elements to read
    std::size_t const elements_to_read =
        std::min(num_elements, total_elements - start_element);
 
    // Calculate offset and size to map
    std::size_t const offset = start_element * sizeof(T);
    std::size_t const size_to_map = elements_to_read * sizeof(T);
 
    // Create a file mapping
    boost::interprocess::file_mapping file(filename.c_str(),
                                           boost::interprocess::read_only);
 
    // Map the specified region
    boost::interprocess::mapped_region region(
        file, boost::interprocess::read_only, offset, size_to_map);
 
    // Get the address of the mapped region
    auto* addr = region.get_address();
 
    // Create vector and copy data
    std::vector<T> result(elements_to_read);
    std::memcpy(result.data(), addr, size_to_map);
 
    if constexpr (std::endian::native != std::endian::little)
    {
        boost::endian::endian_reverse_inplace(result);
    }
 
    return result;
}

References IsFileExisting(), and OGS_FATAL.

◆ readBinaryVector< double >()

template std::vector< double > BaseLib::readBinaryVector< double >	(	std::string const &	,
		std::size_t const	,
		std::size_t const	)

Referenced by readDoublesFromBinaryFile().

◆ readBinaryVector< float >()

template std::vector< float > BaseLib::readBinaryVector< float >	(	std::string const &	,
		std::size_t const	,
		std::size_t const	)

Referenced by FileIO::Gocad::GocadSGridReader::readElementPropertiesBinary().

◆ readDoublesFromBinaryFile()

std::vector< double > BaseLib::readDoublesFromBinaryFile	(	const std::string &	filename,
		const std::string &	project_directory )

Definition at line 242 of file FileTools.cpp.

{
    std::string path_to_file = BaseLib::joinPaths(project_directory, filename);
    std::string file_extension = BaseLib::getFileExtension(filename);
    if (file_extension != ".bin")
    {
        OGS_FATAL(
            "Currently only binary files with extension '.bin' supported. The "
            "specified file has extension {:s}.",
            file_extension)
    }
    return BaseLib::readBinaryVector<double>(path_to_file);
}

References getFileExtension(), joinPaths(), OGS_FATAL, and readBinaryVector< double >().

Referenced by ProcessLib::createOutputConfig(), and MathLib::parsePiecewiseLinearCurveConfig().

◆ removeFile()

void BaseLib::removeFile ( std::string const & filename )

Removes a file. If a file does not exist nothing will happen, other errors lead to OGS_FATAL call.

Definition at line 203 of file FileTools.cpp.

{
    bool const success =
        std::filesystem::remove(std::filesystem::path(filename));
    if (success)
    {
        DBUG("Removed '{:s}'", filename);
    }
}

References DBUG().

Referenced by MainWindow::callGMSH(), consolidateGeometry(), main(), and removeFiles().

◆ removeFiles()

void BaseLib::removeFiles ( std::vector< std::string > const & files )

Remove files. If a file does not exist nothing will happen, other errors lead to OGS_FATAL call.

Definition at line 213 of file FileTools.cpp.

{
    for (auto const& file : files)
    {
        removeFile(file);
    }
}

References removeFile().

Referenced by Simulation::initializeDataStructures().

◆ reorderVector()

template<typename ValueType, typename IndexType>

void BaseLib::reorderVector	(	std::vector< ValueType > &	v,
		std::vector< IndexType > const &	order )

Reorder a vector by a given index vector.

Note: It is good enough in performance for medium size vectors.

Definition at line 221 of file Algorithm.h.

{
    std::vector<ValueType> temp_v(v.size());
    temp_v.swap(v);
 
    for (std::size_t i = 0; i < order.size(); i++)
    {
        std::swap(v[i], temp_v[order[i]]);
    }
}

◆ replaceIncludes()

void BaseLib::replaceIncludes	(	std::stringstream &	prj_stream,
		std::filesystem::path const &	prj_dir )

Definition at line 141 of file PrjProcessing.cpp.

{
    // Parsing the XML triggers floating point exceptions. Because we are not
    // debugging libxml2 (or other libraries) at this point, the floating point
    // exceptions are temporarily disabled and are restored at the end of the
    // function.
    [[maybe_unused]] DisableFPE disable_fpe;
 
    auto doc = xmlReadMemory(prj_stream.str().c_str(), prj_stream.str().size(),
                             nullptr, nullptr, 0);
    if (doc == nullptr)
    {
        OGS_FATAL("Error reading project file from memory.");
    }
 
    auto root_node = xmlDocGetRootElement(doc);
    traverseIncludes(doc, root_node, prj_dir);
 
    xmlChar* xmlbuff;
    int buffersize;
    xmlDocDumpMemory(doc, &xmlbuff, &buffersize);
    prj_stream.str("");  // Empty stream
    prj_stream << xmlbuff;
 
    xmlFree(xmlbuff);
    xmlFreeDoc(doc);
}

References OGS_FATAL, and traverseIncludes().

Referenced by prepareProjectFile().

◆ replaceString()

std::string BaseLib::replaceString	(	const std::string &	searchString,
		const std::string &	replaceString,
		std::string	stringToReplace )

Replaces a substring with another in a string

Parameters

searchString	Search for this string
replaceString	Replace with this string
stringToReplace	Search and replace in this string

Returns: The modified string

Definition at line 42 of file StringTools.cpp.

{
    boost::replace_all(stringToReplace, searchString, replaceString);
    return stringToReplace;
}

References replaceString().

Referenced by GeoLib::Station::createStation(), FileIO::FEFLOWMeshInterface::getIndexList(), FileIO::readDoubleFromStream(), DiagramList::readList(), and replaceString().

◆ setConsoleLogLevel()

void BaseLib::setConsoleLogLevel ( std::string const & level_string )

Definition at line 87 of file Logging.cpp.

{
    using namespace spdlog::level;
    std::map<std::string, level_enum> string_to_log_level = {
        {"none", off},  {"critical", critical}, {"error", err}, {"warn", warn},
        {"info", info}, {"debug", debug},       {"all", trace}};
 
    auto const level = string_to_log_level.find(level_string);
    if (level == string_to_log_level.end())
    {
        ERR("'{:s}' is not a valid log level!", level_string);
        OGS_FATAL("Wrong log level string.");
    }
    console->set_level(level->second);
    spdlog::set_default_logger(console);
}

References console, ERR(), and OGS_FATAL.

Referenced by initOGSLogger().

◆ simplify()

void BaseLib::simplify ( std::string & str )

Removes multiple whitespaces (or other characters) from within a string. Equivalent functionality to Qt::QString::simplify().

Definition at line 68 of file StringTools.cpp.

{
    trim(str);
    str.erase(std::unique(str.begin(),
                          str.end(),
                          [](char a, char b) { return a == ' ' && b == ' '; }),
              str.end());
}

References trim().

Referenced by FileIO::TetGenInterface::getNFacets(), FileIO::TetGenInterface::parseSmeshFacets(), FileIO::TetGenInterface::readElementsFromStream(), and FileIO::TetGenInterface::readNodesFromStream().

◆ sizesToOffsets()

template<ranges::range R>
requires std::is_integral_v<ranges::range_value_t<R>>

std::vector< ranges::range_value_t< R > > BaseLib::sizesToOffsets ( R const & sizes )

Converts range of sizes to a vector of offsets. First offset is 0 and the resulting vector size is the size of the input range plus one.

Definition at line 301 of file Algorithm.h.

{
    return ranges::views::concat(
               ranges::views::single(ranges::range_value_t<R>{0}),
               ranges::views::partial_sum(sizes)) |
           ranges::to<std::vector<ranges::range_value_t<R>>>();
}

Referenced by BaseLib::MPI::allgatherv(), MeshLib::computeNumberOfRegularBaseNodesAtRank(), MeshLib::computeNumberOfRegularHigherOrderNodesAtRank(), MeshLib::computeRegularBaseNodeGlobalNodeIDsOfSubDomainPartition(), getMergedNodesVector(), MeshLib::IO::getPartitionInfo(), and MeshLib::IO::NodePartitionedMeshReader::newMesh().

◆ splitString() [1/2]

std::list< std::string > BaseLib::splitString	(	const std::string &	str,
		char	delim )

Splits a string into a list of strings.

Parameters

str	String to be split
delim	Character indicating that the string should be split

Returns: List of strings

Definition at line 30 of file StringTools.cpp.

{
    std::list<std::string> strList;
    std::stringstream ss(str);
    std::string item;
    while (std::getline(ss, item, delim))
    {
        strList.push_back(item);
    }
    return strList;
}

◆ splitString() [2/2]

std::vector< std::string > BaseLib::splitString ( std::string const & str )

Splits a string into a vector of strings. This method only works for string separation recognised by the std::stringstream iterator such as ' ' or '\t'.

Parameters

str	String to be split

Returns: Vector of strings

Definition at line 20 of file StringTools.cpp.

{
    std::istringstream str_stream(str);
    std::vector<std::string> items;
    std::copy(std::istream_iterator<std::string>(str_stream),
              std::istream_iterator<std::string>(),
              std::back_inserter(items));
    return items;
}

◆ str2number()

template<typename T>

T BaseLib::str2number ( const std::string & str )

Converts a string into a number (double, float, int, ...) Example: std::size_t number (str2number<std::size_t> (str));

Parameters

str	string to be converted

Returns: the number

Definition at line 54 of file StringTools.h.

{
    std::stringstream strs(str, std::stringstream::in | std::stringstream::out);
    T v;
    strs >> v;
    return v;
}

Referenced by GMSHPrefsDialog::accept(), FileIO::SwmmInterface::addPointElevation(), FileIO::FEFLOWMeshInterface::getIndexList(), FileIO::TetGenInterface::getNFacets(), FileIO::TetGenInterface::parseElements(), FileIO::TetGenInterface::parseElementsFileHeader(), FileIO::TetGenInterface::parseNodes(), FileIO::TetGenInterface::parseNodesFileHeader(), FileIO::Gocad::GocadAsciiReader::parseProperties(), FileIO::TetGenInterface::parseSmeshFacets(), FileIO::SwmmInterface::readCoordinates(), FileIO::FEFLOWMeshInterface::readElevation(), FileIO::SwmmInterface::readNodeData(), FileIO::SwmmInterface::readPolygons(), FileIO::Legacy::readPolyline(), FileIO::SwmmInterface::readSubcatchments(), and VtkRaster::readWorldFile().

◆ strDate2int()

int BaseLib::strDate2int ( const std::string & s )

Converts a string containing a date into a double. Note: It is not really checked if the date actually makes sense.

Parameters

s	String containing the date, the expected format is "dd.mm.yyyy".

Returns: A number representing the date as dd.mm.yyyy.

Definition at line 91 of file DateTools.cpp.

{
    std::string str(s);
    if (s.length() > 10)
    {
        str = s.substr(0, 10);
    }
    std::size_t sep(str.find('.', 0));
    int d(atoi(str.substr(0, sep).c_str()));
    std::size_t sep2(str.find('.', sep + 1));
    int m(atoi(str.substr(sep + 1, sep2 - (sep + 1)).c_str()));
    int y(atoi(str.substr(sep2 + 1, s.length() - (sep2 + 1)).c_str()));
    return date2int(y, m, d);
}

References date2int().

Referenced by SensorData::readDataFromFile().

◆ substituteKeyword()

template<typename T>

bool BaseLib::substituteKeyword	(	std::string &	result,
		std::string const &	parenthesized_string,
		std::string::size_type const	begin,
		std::string::size_type const	end,
		std::string const &	keyword,
		T &	data )

Definition at line 62 of file FileTools.cpp.

{
    std::string precision_specification =
        containsKeyword(parenthesized_string, keyword);
 
    if (precision_specification.empty())
    {
        return false;
    }
 
    if constexpr (std::is_same_v<std::remove_cvref_t<T>, bool>)
    {
        if (keyword == "converged")
        {
            std::string r = data ? "" : "_not_converged";
            result.replace(begin, end - begin + 1, r);
            return true;
        }
    }
 
    std::unordered_map<std::type_index, char> type_specification;
    type_specification[std::type_index(typeid(int))] = 'd';
    type_specification[std::type_index(typeid(double))] = 'f';  // default
    type_specification[std::type_index(typeid(std::string))] = 's';
 
    auto const& b = precision_specification.back();
    // see https://fmt.dev/latest/syntax/#format-specification-mini-language
    if (b == 'e' || b == 'E' || b == 'f' || b == 'F' || b == 'g' || b == 'G')
    {
        type_specification[std::type_index(typeid(double))] = b;
        precision_specification.pop_back();
    }
 
    std::string const generated_fmt_string =
        "{" + precision_specification +
        type_specification[std::type_index(typeid(data))] + "}";
    result.replace(
        begin, end - begin + 1,
        fmt::vformat(generated_fmt_string, fmt::make_format_args(data)));
 
    return true;
}

References containsKeyword().

Referenced by constructFormattedFileName().

◆ swapEndianness() [1/2]

double BaseLib::swapEndianness ( double const & v )

Definition at line 143 of file FileTools.cpp.

{
    union
    {
        double v;
        char c[sizeof(double)];
    } a{}, b{};
 
    a.v = v;
    for (unsigned short i = 0; i < sizeof(double) / 2; i++)
    {
        b.c[i] = a.c[sizeof(double) / 2 - i - 1];
    }
 
    for (unsigned short i = sizeof(double) / 2; i < sizeof(double); i++)
    {
        b.c[i] = a.c[sizeof(double) + sizeof(double) / 2 - i - 1];
    }
 
    return b.v;
}

Referenced by FileIO::Gocad::GocadSGridReader::readNodesBinary().

◆ swapEndianness() [2/2]

template<typename T>

T BaseLib::swapEndianness ( T const & v )

Definition at line 54 of file FileTools.h.

{
    union
    {
        T v;
        char c[sizeof(T)];
    } a{}, b{};
 
    a.v = v;
    for (unsigned short i = 0; i < sizeof(T); i++)
    {
        b.c[i] = a.c[sizeof(T) - i - 1];
    }
 
    return b.v;
}

◆ to_underlying()

template<typename E>

auto BaseLib::to_underlying ( E e )

constexprnoexcept

Converts an enumeration to its underlying type.

Parameters

e	Enumeration value to convert

Returns: The integer value of the underlying type of Enum, converted from e.

https://en.cppreference.com/w/cpp/utility/to_underlying Implementation from Scott Meyers : Modern effective c++ , Item 10 Scoped enums

Definition at line 22 of file cpp23.h.

{
    return static_cast<std::underlying_type_t<E>>(e);
}

Referenced by MeshLib::IO::cellTypeOGS2XDMF(), MaterialLib::Solids::MFront::Variable< Derived >::cols(), ProcessLib::createOutputFormat(), MeshLib::IO::elemOGSTypeToXDMFType(), MeshLib::IO::getPropertyDataTypeSize(), MeshLib::IO::getPropertyDataTypeString(), MaterialLib::Solids::Ehlers::SolidEhlers< DisplacementDim >::integrateStress(), MeshLib::IO::meshPropertyDatatypeSize(), MeshLib::IO::meshPropertyDatatypeString(), OGSToVtkCellType(), MaterialLib::Solids::MFront::Variable< Derived >::rows(), MaterialLib::Solids::MFront::OGSMFrontTangentOperatorBlocksView< DisplacementDim, ForcesGradsCombinations >::size(), anonymous_namespace{CreateMFrontGeneric.cpp}::toString(), anonymous_namespace{CreateMFrontGeneric.cpp}::toString(), and MeshLib::IO::transformToXDMFTopology().

◆ traverseIncludes()

void BaseLib::traverseIncludes	(	xmlDoc *	doc,
		xmlNode *	node,
		std::filesystem::path const &	prj_dir )

Definition at line 56 of file PrjProcessing.cpp.

{
    xmlNode* cur_node = nullptr;
    for (cur_node = node; cur_node; cur_node = cur_node->next)
    {
        if (cur_node->type != XML_ELEMENT_NODE)
        {
            continue;
        }
        if (xmlStrEqual(cur_node->name, xmlCharStrdup("include")))
        {
            auto include_file_char_pointer =
                xmlGetProp(cur_node, xmlCharStrdup("file"));
            if (include_file_char_pointer == nullptr)
            {
                OGS_FATAL(
                    "Error while processing includes in prj file. Error in "
                    "element '{:s}' on line {:d}: no file attribute given!",
                    reinterpret_cast<const char*>(cur_node->name),
                    cur_node->line);
            }
            auto filename_length = xmlStrlen(include_file_char_pointer);
            std::string filename(
                reinterpret_cast<char*>(include_file_char_pointer),
                filename_length);
            if (auto const filepath = std::filesystem::path(filename);
                filepath.is_relative())
            {
                filename = (prj_dir / filepath).string();
            }
 
            if (!std::filesystem::exists(filename))
            {
                OGS_FATAL(
                    "Error while processing includes in prj file. Error in "
                    "element '{:s}' on line {:d}: Include file is not "
                    "existing: "
                    "{:s}!",
                    reinterpret_cast<const char*>(cur_node->name),
                    cur_node->line,
                    reinterpret_cast<const char*>(include_file_char_pointer));
            }
            INFO("Including {:s} into project file.", filename);
 
            const std::ifstream input_stream(filename, std::ios_base::binary);
            if (input_stream.fail())
            {
                OGS_FATAL("Failed to open file {}!", filename);
            }
            std::stringstream buffer;
            buffer << input_stream.rdbuf();
            const std::string xml = buffer.str();
 
            // Replace lines containing <?xml ... ?>
            std::regex xmlDeclaration("<\\?xml.*?>");
            const std::string xml_filtered =
                std::regex_replace(xml, xmlDeclaration, "");
 
            xmlNodePtr pNewNode = nullptr;
            xmlParseInNodeContext(cur_node->parent, xml_filtered.c_str(),
                                  (int)xml_filtered.length(), 0, &pNewNode);
            if (pNewNode != nullptr)
            {
                // add new xml node to parent
                xmlNode* pChild = pNewNode;
                while (pChild != nullptr)
                {
                    xmlAddChild(cur_node->parent, xmlCopyNode(pChild, 1));
                    pChild = pChild->next;
                }
                xmlFreeNode(pNewNode);
            }
 
            // Cleanup and continue on next node
            auto next_node = cur_node->next;
            xmlUnlinkNode(cur_node);
            xmlFreeNode(cur_node);
            cur_node = next_node;
        }
        traverseIncludes(doc, cur_node->children, prj_dir);
    }
    xmlFreeNode(cur_node);
}

References INFO(), OGS_FATAL, and traverseIncludes().

Referenced by replaceIncludes(), and traverseIncludes().

◆ trim()

void BaseLib::trim	(	std::string &	str,
		char	ch = ' ' )

Strip whitespace (or other characters) from the beginning and end of a string. Equivalent functionality to Qt::QString::trim().

Definition at line 50 of file StringTools.cpp.

{
    std::string::size_type pos = str.find_last_not_of(ch);
    if (pos != std::string::npos)
    {
        str.erase(pos + 1);
        pos = str.find_first_not_of(ch);
        if (pos != std::string::npos)
        {
            str.erase(0, pos);
        }
    }
    else
    {
        str.erase(str.begin(), str.end());
    }
}

Referenced by FileIO::FEFLOWMeshInterface::getIndexList(), getNumberOfThreadsFromEnv(), getValue(), getVariables(), MeshLib::IO::Legacy::MeshIO::loadMeshFromFile(), FileIO::Gocad::parseGocadPropertyMetaData(), FileIO::Gocad::GocadAsciiReader::parseHeader(), FileIO::FEFLOWMeshInterface::readELEMENTALSETS(), FileIO::FEFLOWMeshInterface::readElevation(), BaseLib::IO::readStringListFromFile(), FileIO::FEFLOWGeoInterface::readSuperMesh(), simplify(), MaterialLib::splitMaterialIdString(), and anonymous_namespace{FEFLOWGeoInterface.cpp}::xmlCharsToString().

◆ tryParseVector()

template<typename T>

std::optional< std::vector< T > > BaseLib::tryParseVector	(	std::string const &	raw,
		std::size_t *	bad_token_idx )

Tries to parse a whitespace-separated list of values from a string. Returns std::nullopt if parsing fails and sets the bad token index.

Definition at line 86 of file StringTools.h.

{
    std::istringstream iss{raw};
 
    // Create a range that reads T values from the stream
    auto values = ranges::istream_view<T>(iss);
    std::vector<T> out = ranges::to<std::vector>(values);
 
    // Check if we consumed the entire input
    if (!iss.eof())
    {
        if (bad_token_idx)
        {
            *bad_token_idx = out.size() + 1;
        }
        return std::nullopt;
    }
    return out;
}

Referenced by BaseLib::ConfigTree::getConfigParameterOptionalImpl(), and ParameterLib::getNamedOrCreateInlineParameter().

◆ type_name()

template<typename T>

const char * BaseLib::type_name ( )

Referenced by BaseLib::TCLAPOutput::tryPrintValue().

◆ type_name< bool >()

template<>

const char * BaseLib::type_name< bool > ( )

Definition at line 37 of file TCLAPOutput.h.

{
    return "bool";
}

◆ type_name< double >()

template<>

const char * BaseLib::type_name< double > ( )

Definition at line 27 of file TCLAPOutput.h.

{
    return "double";
}

◆ type_name< float >()

template<>

const char * BaseLib::type_name< float > ( )

Definition at line 32 of file TCLAPOutput.h.

{
    return "float";
}

◆ type_name< int >()

template<>

const char * BaseLib::type_name< int > ( )

Definition at line 22 of file TCLAPOutput.h.

{
    return "int";
}

◆ type_name< long >()

template<>

const char * BaseLib::type_name< long > ( )

Definition at line 47 of file TCLAPOutput.h.

{
    return "long";
}

◆ type_name< size_t >()

template<>

const char * BaseLib::type_name< size_t > ( )

Definition at line 42 of file TCLAPOutput.h.

{
    return "size_t";
}

◆ type_name< std::string >()

template<>

const char * BaseLib::type_name< std::string > ( )

Definition at line 17 of file TCLAPOutput.h.

{
    return "string";
}

◆ type_name< unsigned >()

template<>

const char * BaseLib::type_name< unsigned > ( )

Definition at line 52 of file TCLAPOutput.h.

{
    return "unsigned";
}

◆ typeToString() [1/2]

template<typename T>

std::string BaseLib::typeToString ( )

Get a human-readable type name for error messages. Uses C++ ABI demangling (GCC/Clang) or UnDecorateSymbolName (MSVC) to convert RTTI symbols into readable type names. Falls back to typeid().name() if demangling fails.

Template overload for explicit type specification: typeToString<SomeType>()

Definition at line 30 of file DemangleTypeInfo.h.

{
    return demangle(typeid(T).name());
}

References demangle().

Referenced by ParameterLib::CoordinateSystem::CoordinateSystem(), ParameterLib::CoordinateSystem::CoordinateSystem(), ProcessLib::LIE::PostProcessTool::PostProcessTool(), BaseLib::MPI::allRanksThrowOrNone(), MeshLib::VtkMeshConverter::convertTypedArray(), createGenericIntegrationMethod(), MeshToolsLib::createSfcMeshProperties(), MaterialPropertyLib::Property::d2Value(), MaterialPropertyLib::Property::dValue(), MaterialPropertyLib::Property::dValue(), MeshLib::Properties::existsPropertyVector(), MeshLib::Properties::existsPropertyVector(), MeshLib::Properties::getPropertyVector(), MaterialPropertyLib::Property::initialValue(), ProcessLib::Graph::detail::isEvalOrderCorrectRT(), anonymous_namespace{BoundaryElementsAlongPolyline.cpp}::modifyEdgeNodeOrdering(), MeshLib::VtkMappedMeshSource::RequestData(), transfer(), MaterialPropertyLib::Property::value(), MaterialPropertyLib::Property::value(), MaterialPropertyLib::Property::value(), and MeshToolsLib::MeshInformation::writePropertyVectorInformation().

◆ typeToString() [2/2]

template<typename T>

std::string BaseLib::typeToString ( T && )

Template overload for type deduction from values: typeToString(some_value) This allows demangling without explicit decltype() in the call.

Definition at line 39 of file DemangleTypeInfo.h.

{
    return demangle(typeid(std::remove_cvref_t<T>).name());
}

References demangle().

◆ uniquePushBack()

template<typename Container>

void BaseLib::uniquePushBack	(	Container &	container,
		typename Container::value_type const &	element )

Definition at line 234 of file Algorithm.h.

{
    if (std::find(container.begin(), container.end(), element) ==
        container.end())
    {
        container.push_back(element);
    }
}

Referenced by GeoLib::EarClippingTriangulation::clipEars().

◆ writeValueBinary()

template<typename T>

void BaseLib::writeValueBinary	(	std::ostream &	out,
		T const &	val )

write value as binary into the given output stream

Template Parameters

T	data type of the value

Parameters

out	output stream, have to be opened in binary mode
val	value

Definition at line 328 of file FileTools.cpp.

{
    out.write(reinterpret_cast<const char*>(&val), sizeof(T));
}

Referenced by ApplicationUtils::writeProperties().

◆ writeValueBinary< std::size_t >()

template void BaseLib::writeValueBinary< std::size_t >	(	std::ostream &	,
		std::size_t const &	)

◆ xmlDate2int()

int BaseLib::xmlDate2int ( const std::string & s )

Converts a string containing a date into a double. Note: It is not really checked if the date actually makes sense.

Parameters

s	String containing the date, the expected format is conform to the xml date type, i.e. "yyyy-mm-dd".

Returns: A number representing the date as yyyymmdd.

Definition at line 106 of file DateTools.cpp.

{
    if (s.length() == 10)
    {
        int d = atoi(s.substr(8, 2).c_str());
        if (d < 1 || d > 31)
        {
            WARN("xmlDate2double(): day not in [1:31].");
        }
        int m = atoi(s.substr(5, 2).c_str());
        if (m < 1 || m > 12)
        {
            WARN("xmlDate2double(): month not in [1:12].");
        }
        int y = atoi(s.substr(0, 4).c_str());
        return date2int(y, m, d);
    }
    return 0;
}

References date2int(), and WARN().

Referenced by GeoLib::StationBorehole::createStation().

Variable Documentation

◆ console

BASELIB_EXPORT std::shared_ptr< spdlog::logger > BaseLib::console

Definition at line 85 of file Logging.cpp.

Referenced by CRITICAL(), DBUG(), ERR(), INFO(), initializeLogger(), initOGSLogger(), setConsoleLogLevel(), and WARN().

Namespaces

Classes

Functions

Variables

Function Documentation

◆ all_of()

◆ any_of()

◆ checkAndInvalidate() [1/3]

◆ checkAndInvalidate() [2/3]

◆ checkAndInvalidate() [3/3]

◆ cleanupVectorElements() [1/2]

◆ cleanupVectorElements() [2/2]

◆ constructFormattedFileName()

◆ containsKeyword()

◆ createOutputDirectory()

◆ date2int()

◆ date2string()

◆ defaultLogLevel()

◆ demangle()

◆ dropFileExtension()

◆ excludeObjectCopy() [1/2]

◆ excludeObjectCopy() [2/2]

◆ extractBaseName()

◆ extractBaseNameWithoutExtension()

◆ extractPath()

◆ findElementOrError()

◆ findFirstNotEqualElement()

◆ findIndex()

◆ format()

◆ formatDate()

◆ getDuplicates()

◆ getFileExtension()

◆ getIfOrError()

◆ getNumberOfAssemblyThreads()

◆ getNumberOfChemistryThreads()

◆ getNumberOfThreads()

◆ getNumberOfThreadsFromEnv()

◆ getOrError() [1/2]

◆ getOrError() [2/2]

◆ getParenthesizedString()

◆ getUniqueName()

◆ hasFileExtension()

◆ initOGSLogger()

◆ insertIfKeyUniqueElseError()

◆ int2date()

◆ IsFileExisting()

◆ joinPaths()

◆ makeConfigTree()

◆ makeConfigTreeFromFile()

◆ makeLogLevelArg()

◆ makeVectorUnique() [1/2]

◆ makeVectorUnique() [2/2]

◆ none_of()

◆ operator<<() [1/2]

◆ operator<<() [2/2]

◆ parseInteger()

◆ patchStream()

◆ prepareProjectFile()

◆ quicksort() [1/5]

◆ quicksort() [2/5]

◆ quicksort() [3/5]

◆ quicksort() [4/5]

◆ quicksort() [5/5]

◆ randomString()

◆ readAndPatchPrj()

◆ readBinaryValue()

◆ readBinaryValue< double >()

◆ readBinaryValue< float >()

◆ readBinaryVector()

◆ readBinaryVector< double >()

◆ readBinaryVector< float >()

◆ readDoublesFromBinaryFile()

◆ removeFile()

◆ removeFiles()

◆ reorderVector()

◆ replaceIncludes()

◆ replaceString()

◆ setConsoleLogLevel()

◆ simplify()

◆ sizesToOffsets()