This chapter represents documentation about basic elements. More...

Topics
	Iterators
	simple alternative to boost/iterator_range

Namespaces
namespace	MR::BitSetParallel

Classes
class	MR::SetBitIteratorT< T >
	iterator to enumerate all indices with set bits in BitSet class or its derivatives More...
class	MR::BitSet
class	MR::TypedBitSet< I >
struct	MR::IdRange< Id >
	range of indices [beg, end) More...
class	MR::Buffer< V, I >
	std::vector<V>-like container that is 1) resized without initialization of its elements, 2) much simplified: no push_back and many other methods More...
class	MR::Heap< T, I, P >
	stores map from element id in[0, size) to T; More...
class	MR::Logger
	Make default spd logger. More...
class	MR::LoggingStreambuf
	A custom streambuf that outputs things directly to the default spdlog logger. More...
class	MR::RestoringStreamsSink
class	MR::Timer
struct	MR::SimpleTimeRecord
struct	MR::TimeRecord
struct	MR::ThreadRootTimeRecord
class	MR::UnionFind< I >
	Union-find data structure for representing disjoin sets of elements with few very quick operations: 1) union of two sets in one, 2) checking whether two elements pertain to the same set, 3) finding representative element (root) of each set by any set's element. More...
class	MR::Vector< T, I >
	std::vector<T>-like container that requires specific indexing type, More...

Functions
size_t	MR::heapBytes (const BitSet &bs)
	returns the amount of memory given BitSet occupies on heap
bool	MR::operator== (const BitSet &a, const BitSet &b)
	compare that two bit sets have the same set bits (they can be equal even if sizes are distinct but last bits are off)
template<typename I>
bool	MR::operator== (const TypedBitSet< I > &a, const TypedBitSet< I > &b)
template<typename T, typename U>
void	MR::operator== (const TypedBitSet< T > &a, const TypedBitSet< U > &b)=delete
	prohibit comparison of unrelated sets
template<typename I>
std::function< bool(I)>	MR::makePredicate (const TypedBitSet< I > *bitset)
template<typename I>
std::function< bool(I)>	MR::makePredicate (const TypedBitSet< I > &bitset)
template<typename I>
bool	MR::contains (const TypedBitSet< I > *bitset, I id)
template<typename I>
bool	MR::contains (const TypedBitSet< I > &bitset, I id)
template<typename I>
void	MR::fillVectorWithSeqNums (const TypedBitSet< I > &bs, Vector< int, I > &vec)
	for each set bit of input bitset, writes its sequential number starting from 0 in the given vector that shall have appropriate size
template<typename I>
Vector< int, I >	MR::makeVectorWithSeqNums (const TypedBitSet< I > &bs)
	creates a Vector where for each set bit of input bitset its sequential number starting from 0 is returned; and -1 for reset bits
template<typename I>
HashMap< I, int >	MR::makeHashMapWithSeqNums (const TypedBitSet< I > &bs)
	creates a HashMap where for each set bit of input bitset its sequential number starting from 0 is returned
BitSet	MR::operator& (const BitSet &a, const BitSet &b)
BitSet	MR::operator\| (const BitSet &a, const BitSet &b)
BitSet	MR::operator^ (const BitSet &a, const BitSet &b)
BitSet	MR::operator- (const BitSet &a, const BitSet &b)
template<typename BS, typename ... F>
auto	MR::BitSetParallelForAllRanged (const BS &bs, F &&... f)
template<typename BS, typename L, typename ... F>
auto	MR::BitSetParallelForAllRanged (const BS &bs, tbb::enumerable_thread_specific< L > &e, F &&... f)
template<typename BS, typename F, typename ... Cb>
auto	MR::BitSetParallelForAll (const BS &bs, F &&f, Cb &&... cb)
template<typename BS, typename L, typename F, typename ... Cb>
auto	MR::BitSetParallelForAll (const BS &bs, tbb::enumerable_thread_specific< L > &e, F &&f, Cb &&... cb)
template<typename BS, typename F, typename ... Cb>
auto	MR::BitSetParallelFor (const BS &bs, F &&f, Cb &&... cb)
template<typename BS, typename L, typename F, typename ... Cb>
auto	MR::BitSetParallelFor (const BS &bs, tbb::enumerable_thread_specific< L > &e, F &&f, Cb &&... cb)
template<typename T>
size_t	MR::heapBytes (const std::vector< T > &vec)
	returns the amount of memory given vector occupies on heap
template<typename T, typename U>
size_t	MR::heapBytes (const Vector< T, U > &vec)
template<typename T>
size_t	MR::heapBytes (const std::unique_ptr< T > &ptr)
	returns the amount of memory this smart pointer and its pointed object own together on heap
template<typename T>
size_t	MR::heapBytes (const std::shared_ptr< T > &ptr)
	returns the amount of memory this smart pointer and its pointed object own together on heap
template<typename T>
	MR::MR_REQUIRES_IF_SUPPORTED (std::is_function_v< T >) inline size_t heapBytes(const std
template<typename ... Ts>
size_t	MR::heapBytes (const phmap::flat_hash_map< Ts... > &hashMap)
	returns the amount of memory given HashMap occupies on heap
void	MR::parallelFor (size_t begin, size_t end, FunctionRef< void(size_t)> f)
void	MR::parallelFor (size_t begin, size_t end, FunctionRef< void(size_t, void )> f, FunctionRef< void ()> ctx)
bool	MR::parallelFor (size_t begin, size_t end, FunctionRef< void(size_t, void )> f, FunctionRef< void ()> ctx, ProgressCallback cb, size_t reportProgressEvery=1024)
template<typename I, typename F, typename ... Cb>
auto	MR::ParallelFor (I begin, I end, F &&f, Cb &&... cb)
template<typename I, typename L, typename F, typename ... Cb>
auto	MR::ParallelFor (I begin, I end, tbb::enumerable_thread_specific< L > &e, F &&f, Cb &&... cb)
template<typename T, typename ... F>
auto	MR::ParallelFor (const std::vector< T > &v, F &&... f)
template<typename T, typename I, typename ... F>
auto	MR::ParallelFor (const Vector< T, I > &v, F &&... f)
template<typename T, typename I, typename ... F>
auto	MR::ParallelFor (const Buffer< T, I > &buf, F &&... f)
void	MR::vertMapsComposition (VertMap &a2b, const VertMap &b2c)
	updates a2b map to a2c map using b2c map
VertMap	MR::vertMapsComposition (const VertMap &a2b, const VertMap &b2c)
	returns map a2c from a2b and b2c maps
void	MR::edgeMapsComposition (EdgeMap &a2b, const EdgeMap &b2c)
	updates a2b map to a2c map using b2c map
EdgeMap	MR::edgeMapsComposition (const EdgeMap &a2b, const EdgeMap &b2c)
	returns map a2c from a2b and b2c maps
void	MR::faceMapsComposition (FaceMap &a2b, const FaceMap &b2c)
	updates a2b map to a2c map using b2c map
FaceMap	MR::faceMapsComposition (const FaceMap &a2b, const FaceMap &b2c)
	returns map a2c from a2b and b2c maps
void	MR::redirectSTDStreamsToLogger ()
size_t	MR::findSubstringCaseInsensitive (const std::string &string, const std::string &substring)
int	MR::calcDamerauLevenshteinDistance (const std::string &stringA, const std::string &stringB, bool caseSensitive=true, int *outLeftRightAddition=nullptr)
std::vector< std::string >	MR::split (const std::string &string, const std::string &delimiter)
MR_BIND_IGNORE std::wstring	MR::utf8ToWide (const char *utf8)
	converts UTF8-encoded string into UTF16-encoded string
std::string	MR::systemToUtf8 (const std::string &system)
	converts system encoded string to UTF8-encoded string
std::string	MR::utf8ToSystem (const std::string &utf8)
MR_BIND_IGNORE std::string	MR::wideToUtf8 (const wchar_t *wide)
	converts wide null terminating string to UTF8-encoded string
MR_BIND_IGNORE const std::string &	MR::asString (const std::string &s)
	std::u8string is not defined
MR_BIND_IGNORE const std::string &	MR::asU8String (const std::string &s)
MR_BIND_IGNORE std::string	MR::asString (std::string &&s)
MR_BIND_IGNORE std::string	MR::asU8String (std::string &&s)
MR_BIND_IGNORE std::filesystem::path	MR::pathFromUtf8 (const std::string &s)
MR_BIND_IGNORE std::filesystem::path	MR::pathFromUtf8 (const char *s)
std::string	MR::utf8string (const std::filesystem::path &path)
	returns filename as UTF8-encoded string
std::string	MR::utf8string (const std::string &)=delete
	it is a mistake to call the function with implicit construction of path from string
std::string	MR::utf8substr (const char *s, size_t pos, size_t count)
std::string	MR::bytesString (size_t size)
bool	MR::isProhibitedChar (char c)
bool	MR::hasProhibitedChars (const std::string &line)
	returns true if line contains at least one character (c) for which isProhibitedChar(c)==true
std::string	MR::replaceProhibitedChars (const std::string &line, char replacement='_')
	replace all characters (c), where isProhibitedChar(c)==true, with replacement char
template<typename T>
Expected< T >	MR::addFileNameInError (Expected< T > v, const std::filesystem::path &file)
	if (v) contains an error, then appends given file name to that error
std::string	MR::commonFilesName (const std::vector< std::filesystem::path > &files)
MR_BIND_IGNORE char *	MR::formatNoTrailingZeros (char *fmt, double v, int digitsAfterPoint, int precision=6)
double	MR::roundToPrecision (double v, int precision)
	returns given value rounded to given number of decimal digits
float	MR::roundToPrecision (float v, int precision)
	returns given value rounded to given number of decimal digits
std::string	MR::getCancelMessage (const std::filesystem::path &path)
	Returns message showed when loading is canceled.
std::string	MR::toLower (std::string str)
	return a copy of the string with all alphabetic ASCII characters replaced with upper-case variants
void	MR::printTimingTreeAtEnd (bool on, double minTimeSec=0.1)
void	MR::printCurrentTimerBranch ()
	prints current timer branch
void	MR::printTimingTree (double minTimeSec=0.1)
MR_BIND_IGNORE void	MR::registerThreadRootTimeRecord (ThreadRootTimeRecord &root)
	installs given record in the current thread (no record must be installed before)
MR_BIND_IGNORE void	MR::unregisterThreadRootTimeRecord (ThreadRootTimeRecord &root)
	un-installs given record in the current thread
template<typename M>
TypedBitSet< I >	MR::TypedBitSet< I >::getMapping (const M &map) const
template<typename M>
TypedBitSet< I >	MR::TypedBitSet< I >::getMapping (const M &map, size_t resSize) const
	MR::Heap< T, I, P >::Heap (size_t size, T def MR_LIFETIMEBOUND_NESTED={}, P pred={})
	constructs heap for given number of elements, assigning given default value to each element
	MR::Heap< T, I, P >::Heap (std::vector< Element > elms MR_LIFETIMEBOUND_NESTED, P pred={})
	constructs heap from given elements (id's shall not repeat and have spaces, but can be arbitrary shuffled)
void	MR::Heap< T, I, P >::resize (size_t size, T def MR_LIFETIME_CAPTURE_BY_NESTED(this)={})
	increases the size of the heap by adding elements at the end
void	MR::Heap< T, I, P >::setValue (I elemId, const T &newVal MR_LIFETIME_CAPTURE_BY_NESTED(this))
	sets new value to given element
void	MR::Heap< T, I, P >::setLargerValue (I elemId, const T &newVal MR_LIFETIME_CAPTURE_BY_NESTED(this))
	sets new value to given element, which shall be larger/smaller than the current value
void	MR::Heap< T, I, P >::setSmallerValue (I elemId, const T &newVal MR_LIFETIME_CAPTURE_BY_NESTED(this))

Detailed Description

This chapter represents documentation about basic elements.

Function Documentation

◆ addFileNameInError()

template<typename T>

Expected< T > MR::addFileNameInError	(	Expected< T >	v,
		const std::filesystem::path &	file )

inlinenodiscard

#include <MRMesh/MRStringConvert.h>

if (v) contains an error, then appends given file name to that error

◆ asString() [1/2]

MR_BIND_IGNORE const std::string & MR::asString ( const std::string & s )

inlinenodiscard

#include <MRMesh/MRStringConvert.h>

std::u8string is not defined

◆ asString() [2/2]

MR_BIND_IGNORE std::string MR::asString ( std::string && s )

inlinenodiscard

#include <MRMesh/MRStringConvert.h>

◆ asU8String() [1/2]

MR_BIND_IGNORE const std::string & MR::asU8String ( const std::string & s )

inlinenodiscard

#include <MRMesh/MRStringConvert.h>

◆ asU8String() [2/2]

MR_BIND_IGNORE std::string MR::asU8String ( std::string && s )

inlinenodiscard

#include <MRMesh/MRStringConvert.h>

◆ BitSetParallelFor() [1/2]

template<typename BS, typename F, typename ... Cb>

auto MR::BitSetParallelFor	(	const BS &	bs,
		F &&	f,
		Cb &&...	cb )

inline

#include <MRMesh/MRBitSetParallelFor.h>

executes given function f for every set bit in IdRange or BitSet (bs) in parallel threads; it is guaranteed that every individual block in bit-set is processed by one thread only; optional parameters after f: ProgressCallback cb, size_t reportProgressEveryBit = 1024 for periodic progress report

Returns: false if terminated by callback

◆ BitSetParallelFor() [2/2]

template<typename BS, typename L, typename F, typename ... Cb>

auto MR::BitSetParallelFor	(	const BS &	bs,
		tbb::enumerable_thread_specific< L > &	e,
		F &&	f,
		Cb &&...	cb )

inline

#include <MRMesh/MRBitSetParallelFor.h>

executes given function f for every set bit in bs IdRange or BitSet (bs) parallel threads, passing e.local() (evaluated once for each sub-range) as the second argument to f; it is guaranteed that every individual block in bit-set is processed by one thread only; optional parameters after f: ProgressCallback cb, size_t reportProgressEveryBit = 1024 for periodic progress report

Returns: false if terminated by callback

◆ BitSetParallelForAll() [1/2]

template<typename BS, typename F, typename ... Cb>

auto MR::BitSetParallelForAll	(	const BS &	bs,
		F &&	f,
		Cb &&...	cb )

inline

#include <MRMesh/MRBitSetParallelFor.h>

executes given function f for each index in IdRange or BitSet (bs) in parallel threads; it is guaranteed that every individual block in BitSet is processed by one thread only; optional parameters after f: ProgressCallback cb, size_t reportProgressEveryBit = 1024 for periodic progress report

Returns: false if terminated by callback

◆ BitSetParallelForAll() [2/2]

template<typename BS, typename L, typename F, typename ... Cb>

auto MR::BitSetParallelForAll	(	const BS &	bs,
		tbb::enumerable_thread_specific< L > &	e,
		F &&	f,
		Cb &&...	cb )

inline

#include <MRMesh/MRBitSetParallelFor.h>

executes given function f for each index in IdRange or BitSet (bs) in parallel threads passing e.local() (evaluated once for each sub-range) as the second argument to f; it is guaranteed that every individual block in BitSet is processed by one thread only; optional parameters after f: ProgressCallback cb, size_t reportProgressEveryBit = 1024 for periodic progress report

Returns: false if terminated by callback

◆ BitSetParallelForAllRanged() [1/2]

template<typename BS, typename ... F>

auto MR::BitSetParallelForAllRanged	(	const BS &	bs,
		F &&...	f )

inline

#include <MRMesh/MRBitSetParallelFor.h>

executes given function f( bit, subBitRange ) for each bit in bitRange in parallel threads, where (subBitRange) are the bits that will be processed by the same thread; it is guaranteed that every individual block in bit-set is processed by one thread only; optional parameters after f: ProgressCallback cb, size_t reportProgressEveryBit = 1024 for periodic progress report

Returns: false if terminated by callback

◆ BitSetParallelForAllRanged() [2/2]

template<typename BS, typename L, typename ... F>

auto MR::BitSetParallelForAllRanged	(	const BS &	bs,
		tbb::enumerable_thread_specific< L > &	e,
		F &&...	f )

inline

#include <MRMesh/MRBitSetParallelFor.h>

executes given function f( bit, subBitRange, tls ) for each bit in IdRange or BitSet (bs) in parallel threads, where subBitRange are the bits that will be processed by the same thread, tls=e.local() (evaluated once for each subBitRange); it is guaranteed that every individual block in bit-set is processed by one thread only; optional parameters after f: ProgressCallback cb, size_t reportProgressEveryBit = 1024 for periodic progress report

Returns: false if terminated by callback

◆ bytesString()

std::string MR::bytesString ( size_t size )

nodiscard

#include <MRMesh/MRStringConvert.h>

converts given size in string: [0,1024) -> nnn bytes [1024,1024*1024) -> nnn.nn Kb [1024*1024,1024*1024*1024) -> nnn.nn Mb ...

◆ calcDamerauLevenshteinDistance()

int MR::calcDamerauLevenshteinDistance	(	const std::string &	stringA,
		const std::string &	stringB,
		bool	caseSensitive = true,
		int *	outLeftRightAddition = nullptr )

nodiscard

#include <MRMesh/MRString.h>

Calculates Damerau-Levenshtein distance between to strings

Parameters

outLeftRightAddition if provided return amount of insertions to the left and to the right

◆ commonFilesName()

std::string MR::commonFilesName ( const std::vector< std::filesystem::path > & files )

nodiscard

#include <MRMesh/MRStringConvert.h>

in case of empty vector, returns "Empty" in case of single input file.ext, returns ".EXT" in case of multiple files with same extension, returns ".EXTs" otherwise returns "Files"

◆ contains() [1/2]

template<typename I>

bool MR::contains	(	const TypedBitSet< I > &	bitset,
		I	id )

inlinenodiscard

#include <MRMesh/MRBitSet.h>

◆ contains() [2/2]

template<typename I>

bool MR::contains	(	const TypedBitSet< I > *	bitset,
		I	id )

inlinenodiscard

#include <MRMesh/MRBitSet.h>

◆ edgeMapsComposition() [1/2]

EdgeMap MR::edgeMapsComposition	(	const EdgeMap &	a2b,
		const EdgeMap &	b2c )

nodiscard

#include <MRMesh/MRPrimitiveMapsComposition.h>

returns map a2c from a2b and b2c maps

◆ edgeMapsComposition() [2/2]

void MR::edgeMapsComposition	(	EdgeMap &	a2b,
		const EdgeMap &	b2c )

#include <MRMesh/MRPrimitiveMapsComposition.h>

updates a2b map to a2c map using b2c map

◆ faceMapsComposition() [1/2]

FaceMap MR::faceMapsComposition	(	const FaceMap &	a2b,
		const FaceMap &	b2c )

nodiscard

#include <MRMesh/MRPrimitiveMapsComposition.h>

returns map a2c from a2b and b2c maps

◆ faceMapsComposition() [2/2]

void MR::faceMapsComposition	(	FaceMap &	a2b,
		const FaceMap &	b2c )

#include <MRMesh/MRPrimitiveMapsComposition.h>

updates a2b map to a2c map using b2c map

◆ fillVectorWithSeqNums()

template<typename I>

void MR::fillVectorWithSeqNums	(	const TypedBitSet< I > &	bs,
		Vector< int, I > &	vec )

#include <MRMesh/MRBitSet.h>

for each set bit of input bitset, writes its sequential number starting from 0 in the given vector that shall have appropriate size

◆ findSubstringCaseInsensitive()

size_t MR::findSubstringCaseInsensitive	(	const std::string &	string,
		const std::string &	substring )

nodiscard

#include <MRMesh/MRString.h>

Finds the substring in the string.

Returns: position, npos if not found

◆ formatNoTrailingZeros()

MR_BIND_IGNORE char * MR::formatNoTrailingZeros	(	char *	fmt,
		double	v,
		int	digitsAfterPoint,
		int	precision = 6 )

#include <MRMesh/MRStringConvert.h>

returns printf-format for floating-point value in decimal notation with given precision in digits and without trailing zeros after the decimal point

Parameters

fmt	preallocated buffer of 5 bytes
v	value to print
digitsAfterPoint	maximal number of digits after decimal point
precision	maximal number of not-zero decimal digits

◆ getCancelMessage()

std::string MR::getCancelMessage ( const std::filesystem::path & path )

inlinenodiscard

#include <MRMesh/MRStringConvert.h>

Returns message showed when loading is canceled.

◆ getMapping() [1/2]

template<typename I>

template<typename M>

TypedBitSet MR::TypedBitSet::getMapping ( const M & map ) const

nodiscard

#include <MRMesh/MRBitSet.h>

◆ getMapping() [2/2]

template<typename I>

template<typename M>

TypedBitSet< I > MR::TypedBitSet< I >::getMapping	(	const M &	map,
		size_t	resSize ) const

nodiscard

#include <MRMesh/MRBitSet.h>

◆ hasProhibitedChars()

bool MR::hasProhibitedChars ( const std::string & line )

nodiscard

#include <MRMesh/MRStringConvert.h>

returns true if line contains at least one character (c) for which isProhibitedChar(c)==true

◆ Heap() [1/2]

template<typename T, typename I, typename P>

MR::Heap< T, I, P >::Heap	(	size_t	size,
		T def	MR_LIFETIMEBOUND_NESTED = {},
		P	pred = {} )

explicit

#include <MRMesh/MRHeap.h>

constructs heap for given number of elements, assigning given default value to each element

◆ Heap() [2/2]

template<typename T, typename I, typename P>

MR::Heap< T, I, P >::Heap	(	std::vector< Element > elms	MR_LIFETIMEBOUND_NESTED,
		P	pred = {} )

explicit

#include <MRMesh/MRHeap.h>

constructs heap from given elements (id's shall not repeat and have spaces, but can be arbitrary shuffled)

◆ heapBytes() [1/6]

size_t MR::heapBytes ( const BitSet & bs )

inlinenodiscard

#include <MRMesh/MRBitSet.h>

returns the amount of memory given BitSet occupies on heap

◆ heapBytes() [2/6]

template<typename ... Ts>

size_t MR::heapBytes ( const phmap::flat_hash_map< Ts... > & hashMap )

inlinenodiscard

#include <MRMesh/MRHeapBytes.h>

returns the amount of memory given HashMap occupies on heap

from parallel_hashmap/phmap.h: The control state and slot array are stored contiguously in a shared heap allocation. The layout of this allocation is: capacity() control bytes, one sentinel control byte, Group::kWidth - 1 cloned control bytes, <possible padding>, capacity() slots

the usage of phmap::priv::Group::kWidth here will require inclusion of phmap.h

◆ heapBytes() [3/6]

template<typename T>

size_t MR::heapBytes ( const std::shared_ptr< T > & ptr )

inlinenodiscard

#include <MRMesh/MRHeapBytes.h>

returns the amount of memory this smart pointer and its pointed object own together on heap

◆ heapBytes() [4/6]

template<typename T>

size_t MR::heapBytes ( const std::unique_ptr< T > & ptr )

inlinenodiscard

#include <MRMesh/MRHeapBytes.h>

returns the amount of memory this smart pointer and its pointed object own together on heap

◆ heapBytes() [5/6]

template<typename T>

size_t MR::heapBytes ( const std::vector< T > & vec )

inlinenodiscard

#include <MRMesh/MRHeapBytes.h>

returns the amount of memory given vector occupies on heap

◆ heapBytes() [6/6]

template<typename T, typename U>

size_t MR::heapBytes ( const Vector< T, U > & vec )

inlinenodiscard

#include <MRMesh/MRHeapBytes.h>

◆ isProhibitedChar()

bool MR::isProhibitedChar ( char c )

inlinenodiscard

#include <MRMesh/MRStringConvert.h>

returns true if the given character is any of prohibited in filenames in any of OSes https:/// stackoverflow.com/q/1976007/7325599

◆ makeHashMapWithSeqNums()

template<typename I>

HashMap< I, int > MR::makeHashMapWithSeqNums ( const TypedBitSet & bs )

nodiscard

#include <MRMesh/MRBitSet.h>

creates a HashMap where for each set bit of input bitset its sequential number starting from 0 is returned

◆ makePredicate() [1/2]

template<typename I>

std::function< bool(I)> MR::makePredicate ( const TypedBitSet & bitset )

inlinenodiscard

#include <MRMesh/MRBitSet.h>

◆ makePredicate() [2/2]

template<typename I>

std::function< bool(I)> MR::makePredicate ( const TypedBitSet * bitset )

inlinenodiscard

#include <MRMesh/MRBitSet.h>

◆ makeVectorWithSeqNums()

template<typename I>

Vector< int, I > MR::makeVectorWithSeqNums ( const TypedBitSet & bs )

nodiscard

#include <MRMesh/MRBitSet.h>

creates a Vector where for each set bit of input bitset its sequential number starting from 0 is returned; and -1 for reset bits

◆ MR_REQUIRES_IF_SUPPORTED()

template<typename T>

MR::MR_REQUIRES_IF_SUPPORTED ( std::is_function_v< T > ) const

nodiscard

#include <MRMesh/MRHeapBytes.h>

Needed for generic code, always returns zero. The constraint is needed to avoid hard errors in C bindings when using MSVC STL when calling heapBytes<SomeNonfuncType>(...).

◆ operator&()

BitSet MR::operator&	(	const BitSet &	a,
		const BitSet &	b )

inlinenodiscard

#include <MRMesh/MRBitSet.h>

◆ operator-()

BitSet MR::operator-	(	const BitSet &	a,
		const BitSet &	b )

inlinenodiscard

#include <MRMesh/MRBitSet.h>

◆ operator==() [1/3]

bool MR::operator==	(	const BitSet &	a,
		const BitSet &	b )

nodiscard

#include <MRMesh/MRBitSet.h>

compare that two bit sets have the same set bits (they can be equal even if sizes are distinct but last bits are off)

◆ operator==() [2/3]

template<typename I>

bool MR::operator==	(	const TypedBitSet< I > &	a,
		const TypedBitSet< I > &	b )

inlinenodiscard

#include <MRMesh/MRBitSet.h>

◆ operator==() [3/3]

template<typename T, typename U>

void MR::operator==	(	const TypedBitSet< T > &	a,
		const TypedBitSet< U > &	b )

delete

#include <MRMesh/MRBitSet.h>

prohibit comparison of unrelated sets

◆ operator^()

BitSet MR::operator^	(	const BitSet &	a,
		const BitSet &	b )

inlinenodiscard

#include <MRMesh/MRBitSet.h>

◆ operator|()

BitSet MR::operator\|	(	const BitSet &	a,
		const BitSet &	b )

inlinenodiscard

#include <MRMesh/MRBitSet.h>

◆ ParallelFor() [1/5]

template<typename T, typename I, typename ... F>

auto MR::ParallelFor	(	const Buffer< T, I > &	buf,
		F &&...	f )

inline

#include <MRMesh/MRParallelFor.h>

executes given function f for each vector element in parallel threads; optional parameters after f: ProgressCallback cb, size_t reportProgressEvery = 1024 for periodic progress report

Returns: false if terminated by callback

◆ ParallelFor() [2/5]

template<typename T, typename ... F>

auto MR::ParallelFor	(	const std::vector< T > &	v,
		F &&...	f )

inline

#include <MRMesh/MRParallelFor.h>

executes given function f for each vector element in parallel threads; optional parameters after f: ProgressCallback cb, size_t reportProgressEvery = 1024 for periodic progress report

Returns: false if terminated by callback

◆ ParallelFor() [3/5]

template<typename T, typename I, typename ... F>

auto MR::ParallelFor	(	const Vector< T, I > &	v,
		F &&...	f )

inline

#include <MRMesh/MRParallelFor.h>

executes given function f for each vector element in parallel threads; optional parameters after f: ProgressCallback cb, size_t reportProgressEvery = 1024 for periodic progress report

Returns: false if terminated by callback

◆ ParallelFor() [4/5]

template<typename I, typename F, typename ... Cb>

auto MR::ParallelFor	(	I	begin,
		I	end,
		F &&	f,
		Cb &&...	cb )

inline

#include <MRMesh/MRParallelFor.h>

executes given function f for each span element [begin, end); optional parameters after f: ProgressCallback cb, size_t reportProgressEvery = 1024 for periodic progress report

Returns: false if terminated by callback

◆ ParallelFor() [5/5]

template<typename I, typename L, typename F, typename ... Cb>

auto MR::ParallelFor	(	I	begin,
		I	end,
		tbb::enumerable_thread_specific< L > &	e,
		F &&	f,
		Cb &&...	cb )

inline

#include <MRMesh/MRParallelFor.h>

executes given function f for each span element [begin, end) passing e.local() (evaluated once for each sub-range) as the second argument to f; optional parameters after f: ProgressCallback cb, size_t reportProgressEvery = 1024 for periodic progress report

Returns: false if terminated by callback

◆ parallelFor() [1/3]

void MR::parallelFor	(	size_t	begin,
		size_t	end,
		FunctionRef< void(size_t)>	f )

#include <MRMesh/MRParallelFor.h>

◆ parallelFor() [2/3]

void MR::parallelFor	(	size_t	begin,
		size_t	end,
		FunctionRef< void(size_t, void *)>	f,
		FunctionRef< void *()>	ctx )

#include <MRMesh/MRParallelFor.h>

◆ parallelFor() [3/3]

bool MR::parallelFor	(	size_t	begin,
		size_t	end,
		FunctionRef< void(size_t, void *)>	f,
		FunctionRef< void *()>	ctx,
		ProgressCallback	cb,
		size_t	reportProgressEvery = 1024 )

#include <MRMesh/MRParallelFor.h>

◆ pathFromUtf8() [1/2]

MR_BIND_IGNORE std::filesystem::path MR::pathFromUtf8 ( const char * s )

inlinenodiscard

#include <MRMesh/MRStringConvert.h>

◆ pathFromUtf8() [2/2]

MR_BIND_IGNORE std::filesystem::path MR::pathFromUtf8 ( const std::string & s )

inlinenodiscard

#include <MRMesh/MRStringConvert.h>

◆ printCurrentTimerBranch()

void MR::printCurrentTimerBranch ( )

#include <MRMesh/MRTimer.h>

prints current timer branch

◆ printTimingTree()

void MR::printTimingTree ( double minTimeSec = 0.1 )

#include <MRMesh/MRTimer.h>

prints the current timing tree

Parameters

minTimeSec omit printing records with time spent less than given value in seconds

◆ printTimingTreeAtEnd()

void MR::printTimingTreeAtEnd	(	bool	on,
		double	minTimeSec = 0.1 )

#include <MRMesh/MRTimer.h>

enables or disables printing of timing tree when application terminates

Parameters

minTimeSec omit printing records with time spent less than given value in seconds

◆ redirectSTDStreamsToLogger()

void MR::redirectSTDStreamsToLogger ( )

#include <MRMesh/MRRestoringStreamsSink.h>

Redirects stdcout stdcerr stdclog to default logger

Note: do not call this function directly if you use MR::setupLoggerByDefault()

◆ registerThreadRootTimeRecord()

MR_BIND_IGNORE void MR::registerThreadRootTimeRecord ( ThreadRootTimeRecord & root )

#include <MRMesh/MRTimeRecord.h>

installs given record in the current thread (no record must be installed before)

◆ replaceProhibitedChars()

std::string MR::replaceProhibitedChars	(	const std::string &	line,
		char	replacement = '_' )

nodiscard

#include <MRMesh/MRStringConvert.h>

replace all characters (c), where isProhibitedChar(c)==true, with replacement char

◆ resize()

template<typename T, typename I, typename P = std::less<T>>

void MR::Heap< T, I, P >::resize	(	size_t	size,
		T def	MR_LIFETIME_CAPTURE_BY_NESTEDthis = {} )

#include <MRMesh/MRHeap.h>

increases the size of the heap by adding elements at the end

◆ roundToPrecision() [1/2]

double MR::roundToPrecision	(	double	v,
		int	precision )

nodiscard

#include <MRMesh/MRStringConvert.h>

returns given value rounded to given number of decimal digits

◆ roundToPrecision() [2/2]

float MR::roundToPrecision	(	float	v,
		int	precision )

inlinenodiscard

#include <MRMesh/MRStringConvert.h>

returns given value rounded to given number of decimal digits

◆ setLargerValue()

template<typename T, typename I, typename P = std::less<T>>

void MR::Heap< T, I, P >::setLargerValue	(	I	elemId,
		const T &newVal	MR_LIFETIME_CAPTURE_BY_NESTEDthis )

#include <MRMesh/MRHeap.h>

sets new value to given element, which shall be larger/smaller than the current value

◆ setSmallerValue()

template<typename T, typename I, typename P = std::less<T>>

void MR::Heap< T, I, P >::setSmallerValue	(	I	elemId,
		const T &newVal	MR_LIFETIME_CAPTURE_BY_NESTEDthis )

#include <MRMesh/MRHeap.h>

◆ setValue()

template<typename T, typename I, typename P = std::less<T>>

void MR::Heap< T, I, P >::setValue	(	I	elemId,
		const T &newVal	MR_LIFETIME_CAPTURE_BY_NESTEDthis )

#include <MRMesh/MRHeap.h>

sets new value to given element

◆ split()

std::vector< std::string > MR::split	(	const std::string &	string,
		const std::string &	delimiter )

nodiscard

#include <MRMesh/MRString.h>

Splits given string by delimiter.

Returns: vector of split strings

◆ systemToUtf8()

std::string MR::systemToUtf8 ( const std::string & system )

nodiscard

#include <MRMesh/MRStringConvert.h>

converts system encoded string to UTF8-encoded string

◆ toLower()

std::string MR::toLower ( std::string str )

nodiscard

#include <MRMesh/MRStringConvert.h>

return a copy of the string with all alphabetic ASCII characters replaced with upper-case variants

◆ unregisterThreadRootTimeRecord()

MR_BIND_IGNORE void MR::unregisterThreadRootTimeRecord ( ThreadRootTimeRecord & root )

#include <MRMesh/MRTimeRecord.h>

un-installs given record in the current thread

◆ utf8string() [1/2]

std::string MR::utf8string ( const std::filesystem::path & path )

inlinenodiscard

#include <MRMesh/MRStringConvert.h>

returns filename as UTF8-encoded string

◆ utf8string() [2/2]

std::string MR::utf8string ( const std::string & )

delete

#include <MRMesh/MRStringConvert.h>

it is a mistake to call the function with implicit construction of path from string

◆ utf8substr()

std::string MR::utf8substr	(	const char *	s,
		size_t	pos,
		size_t	count )

nodiscard

#include <MRMesh/MRStringConvert.h>

given on input a valid utf8-encoded string, returns its substring starting at pos unicode symbol, and containing at most count unicode symbols (but res.size() can be more than count since a unicode symbol can be represented by more than 1 byte)

◆ utf8ToSystem()

std::string MR::utf8ToSystem ( const std::string & utf8 )

nodiscard

#include <MRMesh/MRStringConvert.h>

converts UTF8-encoded string to system encoded string, returns empty string if such conversion cannot be made

◆ utf8ToWide()

MR_BIND_IGNORE std::wstring MR::utf8ToWide ( const char * utf8 )

nodiscard

#include <MRMesh/MRStringConvert.h>

converts UTF8-encoded string into UTF16-encoded string

◆ vertMapsComposition() [1/2]

VertMap MR::vertMapsComposition	(	const VertMap &	a2b,
		const VertMap &	b2c )

nodiscard

#include <MRMesh/MRPrimitiveMapsComposition.h>

returns map a2c from a2b and b2c maps

◆ vertMapsComposition() [2/2]

void MR::vertMapsComposition	(	VertMap &	a2b,
		const VertMap &	b2c )

#include <MRMesh/MRPrimitiveMapsComposition.h>

updates a2b map to a2c map using b2c map

◆ wideToUtf8()

MR_BIND_IGNORE std::string MR::wideToUtf8 ( const wchar_t * wide )

nodiscard

#include <MRMesh/MRStringConvert.h>

converts wide null terminating string to UTF8-encoded string

Topics

Namespaces

Classes

Functions

Detailed Description

Function Documentation

◆ addFileNameInError()

◆ asString() [1/2]

◆ asString() [2/2]

◆ asU8String() [1/2]

◆ asU8String() [2/2]

◆ BitSetParallelFor() [1/2]

◆ BitSetParallelFor() [2/2]

◆ BitSetParallelForAll() [1/2]

◆ BitSetParallelForAll() [2/2]

◆ BitSetParallelForAllRanged() [1/2]

◆ BitSetParallelForAllRanged() [2/2]

◆ bytesString()

◆ calcDamerauLevenshteinDistance()

◆ commonFilesName()

◆ contains() [1/2]

◆ contains() [2/2]

◆ edgeMapsComposition() [1/2]

◆ edgeMapsComposition() [2/2]

◆ faceMapsComposition() [1/2]

◆ faceMapsComposition() [2/2]

◆ fillVectorWithSeqNums()

◆ findSubstringCaseInsensitive()

◆ formatNoTrailingZeros()

◆ getCancelMessage()

◆ getMapping() [1/2]

◆ getMapping() [2/2]

◆ hasProhibitedChars()

◆ Heap() [1/2]

◆ Heap() [2/2]

◆ heapBytes() [1/6]

◆ heapBytes() [2/6]

◆ heapBytes() [3/6]

◆ heapBytes() [4/6]

◆ heapBytes() [5/6]

◆ heapBytes() [6/6]

◆ isProhibitedChar()

◆ makeHashMapWithSeqNums()

◆ makePredicate() [1/2]

◆ makePredicate() [2/2]

◆ makeVectorWithSeqNums()

◆ MR_REQUIRES_IF_SUPPORTED()

◆ operator&()

◆ operator-()

◆ operator==() [1/3]

◆ operator==() [2/3]

◆ operator==() [3/3]

◆ operator^()

◆ operator|()

◆ ParallelFor() [1/5]

◆ ParallelFor() [2/5]

◆ ParallelFor() [3/5]

◆ ParallelFor() [4/5]

◆ ParallelFor() [5/5]

◆ parallelFor() [1/3]

◆ parallelFor() [2/3]

◆ parallelFor() [3/3]

◆ pathFromUtf8() [1/2]

◆ pathFromUtf8() [2/2]

◆ printCurrentTimerBranch()

◆ printTimingTree()

◆ printTimingTreeAtEnd()

◆ redirectSTDStreamsToLogger()

◆ registerThreadRootTimeRecord()

◆ replaceProhibitedChars()

◆ resize()

◆ roundToPrecision() [1/2]

◆ roundToPrecision() [2/2]

◆ setLargerValue()

◆ setSmallerValue()

◆ setValue()

◆ split()

◆ systemToUtf8()

◆ toLower()

◆ unregisterThreadRootTimeRecord()