Basic elements overview

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::BaseUnionFind< I >
	base of union-find data structures: stores only the parent forest and the operations that depend on it alone, so it is shared by the sequential UnionFind and the ParallelUnionFind More...
class	MR::UnionFind< I >
	Union-find data structure for representing disjoint 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. Sequential implementation that selects the root of a united pair by set size for best performance. More...
class	MR::ParallelUnionFind< I >
	Union-find that supports lock-free concurrent construction via uniteAtomic(). It links by element id (the smaller id becomes the set root), which keeps the forest acyclic without locks; consequently it does not maintain set sizes (use BaseUnionFind::roots() to read the result). 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
HashMap< size_t, size_t >	MR::makeHashMapWithSeqNums (const BitSet &bs)
	creates a HashMap where for each set bit of input bitset its sequential number starting from 0 is returned
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)
MR_BIND_IGNORE BitSet	MR::operator& (BitSet &&a, const BitSet &b)
MR_BIND_IGNORE BitSet	MR::operator| (BitSet &&a, const BitSet &b)
MR_BIND_IGNORE BitSet	MR::operator^ (BitSet &&a, const BitSet &b)
MR_BIND_IGNORE BitSet	MR::operator- (BitSet &&a, const BitSet &b)
MR_BIND_IGNORE BitSet	MR::operator& (const BitSet &a, BitSet &&b)
MR_BIND_IGNORE BitSet	MR::operator| (const BitSet &a, BitSet &&b)
MR_BIND_IGNORE BitSet	MR::operator^ (const BitSet &a, BitSet &&b)
MR_BIND_IGNORE BitSet	MR::operator& (BitSet &&a, BitSet &&b)
MR_BIND_IGNORE BitSet	MR::operator| (BitSet &&a, BitSet &&b)
MR_BIND_IGNORE BitSet	MR::operator^ (BitSet &&a, 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)> f, tbb::task_group_context &tgc)
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 F>
void	MR::ParallelFor (I begin, I end, F &&f, tbb::task_group_context &tgc)
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)
MR_BIND_IGNORE std::pair< char32_t, size_t >	MR::utf8ToCodepoint (const char *s, size_t size)
MR_BIND_IGNORE std::u32string	MR::utf8ToUtf32 (const std::string &str)
	Converts the given UTF-8 encoded string to a UTF-32 encoded string.
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< I > MR::TypedBitSet< I >::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() [1/2]

HashMap< size_t, size_t > MR::makeHashMapWithSeqNums ( const BitSet & 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

makeHashMapWithSeqNums() [2/2]

template<typename I>

HashMap< I, int > MR::makeHashMapWithSeqNums ( const TypedBitSet< I > & 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< I > & bitset )

inlinenodiscard

#include <MRMesh/MRBitSet.h>

makePredicate() [2/2]

template<typename I>

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

inlinenodiscard

#include <MRMesh/MRBitSet.h>

makeVectorWithSeqNums()

template<typename I>

Vector< int, I > MR::makeVectorWithSeqNums ( const TypedBitSet< I > & 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&() [1/4]

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

inlinenodiscard

#include <MRMesh/MRBitSet.h>

operator&() [2/4]

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

inlinenodiscard

#include <MRMesh/MRBitSet.h>

operator&() [3/4]

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

inlinenodiscard

#include <MRMesh/MRBitSet.h>

operator&() [4/4]

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

inlinenodiscard

#include <MRMesh/MRBitSet.h>

operator-() [1/2]

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

inlinenodiscard

#include <MRMesh/MRBitSet.h>

operator-() [2/2]

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^() [1/4]

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

inlinenodiscard

#include <MRMesh/MRBitSet.h>

operator^() [2/4]

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

inlinenodiscard

#include <MRMesh/MRBitSet.h>

operator^() [3/4]

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

inlinenodiscard

#include <MRMesh/MRBitSet.h>

operator^() [4/4]

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

inlinenodiscard

#include <MRMesh/MRBitSet.h>

operator|() [1/4]

MR_BIND_IGNORE BitSet MR::operator| ( BitSet && a, BitSet && b )

inlinenodiscard

#include <MRMesh/MRBitSet.h>

operator|() [2/4]

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

inlinenodiscard

#include <MRMesh/MRBitSet.h>

operator|() [3/4]

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

inlinenodiscard

#include <MRMesh/MRBitSet.h>

operator|() [4/4]

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

inlinenodiscard

#include <MRMesh/MRBitSet.h>

ParallelFor() [1/6]

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/6]

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/6]

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/6]

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/6]

template<typename I, typename F>

void MR::ParallelFor ( I begin, I end, F && f, tbb::task_group_context & tgc )

inline

#include <MRMesh/MRParallelFor.h>

executes given function f for each span element [begin, end); tbb::task_group_context can be used to interrupt execution prematurely

ParallelFor() [6/6]

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/4]

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

#include <MRMesh/MRParallelFor.h>

parallelFor() [2/4]

void MR::parallelFor	(	size_t	begin,
		size_t	end,
		FunctionRef< void(size_t)>	f,
		tbb::task_group_context &	tgc )

#include <MRMesh/MRParallelFor.h>

parallelFor() [3/4]

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

#include <MRMesh/MRParallelFor.h>

parallelFor() [4/4]

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)

utf8ToCodepoint()

MR_BIND_IGNORE std::pair< char32_t, size_t > MR::utf8ToCodepoint ( const char * s, size_t size )

nodiscard

#include <MRMesh/MRStringConvert.h>

Reads the first code point from the given UTF-8 encoded string and returns the code point and a number of consumed bytes. If the string starts from an invalid UTF-8 sequence, the replacement character (U+FFFD) is returned. Note that the function checks neither for the null pointer nor for the null character; it is user responsibility to pass correct values.

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

utf8ToUtf32()

MR_BIND_IGNORE std::u32string MR::utf8ToUtf32 ( const std::string & str )

nodiscard

#include <MRMesh/MRStringConvert.h>

Converts the given UTF-8 encoded string to a UTF-32 encoded string.

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