SimGrid  3.21
Versatile Simulation of Distributed Systems
simgrid::xbt Namespace Reference

Namespaces

 bits
 

Classes

class  Extendable
 An Extendable is an object that you can extend with external elements. More...
 
class  Extension
 
class  HeapComparator
 Comparator class for using with std::priority_queue or boost::heap. More...
 
class  integer_sequence
 A compile-time sequence of integers (from C++14) More...
 
class  MainFunction
 
class  Path
 
class  Range
 Describes a contiguous inclusive-exclusive [a,b) range of values. More...
 
class  Result
 A value or an exception (or nothing) More...
 
class  Result< T & >
 
class  Result< void >
 
class  signal
 
class  signal< R(P...)>
 A signal/slot mechanism. More...
 
class  Task
 
class  Task< R(Args...)>
 Type-erased run-once task. More...
 
class  TaskImpl
 
class  ThrowPoint
 Contextual information about an execution location (file:line:func and backtrace, procname, pid) More...
 

Typedefs

typedef std::vector< xbt_backtrace_location_tBacktrace
 A backtrace. More...
 
typedef std::vector< std::string > ReplayAction
 
typedef std::string string
 
template<class T , T N>
using make_integer_sequence = typename simgrid::xbt::bits::make_integer_sequence< T, N >::type
 A compile-time sequence of integers of the form (0,1,2,3,...,N-1) (from C++14) More...
 
template<std::size_t... Ints>
using index_sequence = integer_sequence< std::size_t, Ints... >
 A compile-time sequence of indices (from C++14) More...
 
template<std::size_t N>
using make_index_sequence = make_integer_sequence< std::size_t, N >
 A compile-time sequence of indices of the form (0,1,2,3,...,N-1) (from C++14) More...
 
template<class... T>
using index_sequence_for = make_index_sequence< sizeof...(T)>
 Convert a type parameter pack into a index_sequence (from C++14) More...
 

Functions

template<class F >
xbt_automaton_propositional_symbol_t add_proposition (xbt_automaton_t a, const char *id, F f)
 Add a proposition to an automaton (the C++ way) More...
 
std::vector< xbt_backtrace_location_tbacktrace ()
 Get the current backtrace. More...
 
std::vector< std::string > resolve_backtrace (xbt_backtrace_location_t const *loc, std::size_t count)
 
std::vector< std::string > resolveBacktrace (xbt_backtrace_location_t const *loc, std::size_t count)
 
template<class T >
xbt_dynar_t newDeleteDynar ()
 Dynar of T* which delete its values. More...
 
template<class F >
std::function< void()> wrap_main (F code, std::vector< std::string > args)
 
template<class F >
std::function< void()> wrap_main (F code, int argc, const char *const argv[])
 
template<class F , class Tuple >
constexpr auto apply (F &&f, Tuple &&t) -> decltype(simgrid::xbt::bits::apply(std::forward< F >(f), std::forward< Tuple >(t), simgrid::xbt::make_index_sequence< std::tuple_size< typename std::decay< Tuple >::type >::value >()))
 Call a functional object with the values in the given tuple (from C++17) More...
 
template<class F , class... Args>
auto make_task (F code, Args... args) -> Task< decltype(code(std::move(args)...))()>
 
template<class F , class... Args>
auto makeTask (F code, Args... args) -> Task< decltype(code(std::move(args)...))()>
 
template<class F >
std::function< void()> wrapMain (F code, std::vector< std::string > args)
 
template<class F >
std::function< void()> wrapMain (F code, int argc, const char *const argv[])
 
template<class R , class F >
auto fulfill_promise (R &promise, F &&code) -> decltype(promise.set_value(code()))
 Execute some code and set a promise or result accordingly. More...
 
template<class R , class F >
auto fulfillPromise (R &promise, F &&code) -> decltype(promise.set_value(code()))
 
template<class P , class F >
auto fulfill_promise (P &promise, F &&code) -> decltype(promise.set_value())
 
template<class P , class F >
auto fulfillPromise (P &promise, F &&code) -> decltype(promise.set_value())
 
template<class P , class F >
void set_promise (P &promise, F &&future)
 Set a promise/result from a future/result. More...
 
template<class P , class F >
void setPromise (P &promise, F &&future)
 
void log_exception (e_xbt_log_priority_t priority, const char *context, std::exception const &exception)
 Display informations about an exception. More...
 
void install_exception_handler ()
 
void logException (e_xbt_log_priority_t priority, const char *context, std::exception const &exception)
 
void installExceptionHandler ()
 
int replay_runner (int argc, char *argv[])
 
std::string string_printf (const char *fmt,...)
 Create a C++ string from a C-style format. More...
 
std::string string_vprintf (const char *fmt, va_list ap)
 Create a C++ string from a C-style format. More...
 
const std::error_category & errno_category () noexcept
 A error_category suitable to be used with errno More...
 
std::error_code errno_code (int errnum)
 Create a error_code from an errno value. More...
 
std::error_code errno_code ()
 Create an error_code from errno (and clear it) More...
 
std::system_error errno_error (int errnum)
 Create a system_error from an errno value. More...
 
std::system_error errno_error (int errnum, const char *what)
 
std::system_error errno_error ()
 Create a system_code from errno (and clear it) More...
 
std::system_error errno_error (const char *what)
 
template<class List , class Elem >
void intrusive_erase (List &list, Elem &elem)
 Erase an element given by reference from a boost::intrusive::list. More...
 

Variables

std::unique_ptr< char, void(*)(void *)> demangle (const char *name)
 Try to demangle a C++ name. More...
 
std::ifstream * action_fs
 

Typedef Documentation

◆ ReplayAction

typedef std::vector<std::string> simgrid::xbt::ReplayAction

◆ string

typedef std::string simgrid::xbt::string

◆ make_integer_sequence

template<class T , T N>
using simgrid::xbt::make_integer_sequence = typedef typename simgrid::xbt::bits::make_integer_sequence<T,N>::type

A compile-time sequence of integers of the form (0,1,2,3,...,N-1) (from C++14)

◆ index_sequence

template<std::size_t... Ints>
using simgrid::xbt::index_sequence = typedef integer_sequence<std::size_t, Ints...>

A compile-time sequence of indices (from C++14)

◆ make_index_sequence

template<std::size_t N>
using simgrid::xbt::make_index_sequence = typedef make_integer_sequence<std::size_t, N>

A compile-time sequence of indices of the form (0,1,2,3,...,N-1) (from C++14)

◆ index_sequence_for

template<class... T>
using simgrid::xbt::index_sequence_for = typedef make_index_sequence<sizeof...(T)>

Convert a type parameter pack into a index_sequence (from C++14)

Function Documentation

◆ add_proposition()

template<class F >
xbt_automaton_propositional_symbol_t simgrid::xbt::add_proposition ( xbt_automaton_t  a,
const char *  id,
f 
)

Add a proposition to an automaton (the C++ way)

This API hides all the callback and dynamic allocation hell from the used which can use C++ style functors and lambda expressions.

◆ backtrace()

std::vector<xbt_backtrace_location_t> simgrid::xbt::backtrace ( )

Get the current backtrace.

◆ resolve_backtrace()

std::vector<std::string> simgrid::xbt::resolve_backtrace ( xbt_backtrace_location_t const *  loc,
std::size_t  count 
)

◆ resolveBacktrace()

std::vector<std::string> simgrid::xbt::resolveBacktrace ( xbt_backtrace_location_t const *  loc,
std::size_t  count 
)

◆ newDeleteDynar()

template<class T >
xbt_dynar_t simgrid::xbt::newDeleteDynar ( )
inline

Dynar of T* which delete its values.

◆ wrap_main() [1/2]

template<class F >
std::function<void()> simgrid::xbt::wrap_main ( code,
std::vector< std::string >  args 
)
inline

◆ wrap_main() [2/2]

template<class F >
std::function<void()> simgrid::xbt::wrap_main ( code,
int  argc,
const char *const  argv[] 
)
inline

◆ apply()

template<class F , class Tuple >
constexpr auto simgrid::xbt::apply ( F &&  f,
Tuple &&  t 
) -> decltype(simgrid::xbt::bits::apply( std::forward<F>(f), std::forward<Tuple>(t), simgrid::xbt::make_index_sequence< std::tuple_size<typename std::decay<Tuple>::type>::value >()))

Call a functional object with the values in the given tuple (from C++17)

int foo(int a, bool b);
auto args = std::make_tuple(1, false);
int res = apply(foo, args);

◆ make_task()

template<class F , class... Args>
auto simgrid::xbt::make_task ( code,
Args...  args 
) -> Task<decltype(code(std::move(args)...))()>

◆ makeTask()

template<class F , class... Args>
auto simgrid::xbt::makeTask ( code,
Args...  args 
) -> Task<decltype(code(std::move(args)...))()>

◆ wrapMain() [1/2]

template<class F >
std::function<void()> simgrid::xbt::wrapMain ( code,
std::vector< std::string >  args 
)
inline

◆ wrapMain() [2/2]

template<class F >
std::function<void()> simgrid::xbt::wrapMain ( code,
int  argc,
const char *const  argv[] 
)
inline

◆ fulfill_promise() [1/2]

template<class R , class F >
auto simgrid::xbt::fulfill_promise ( R &  promise,
F &&  code 
) -> decltype(promise.set_value(code()))

Execute some code and set a promise or result accordingly.

Roughly this does:

promise.set_value(code());

but it takes care of exceptions and works with void.

We might need this when working with generic code because the trivial implementation does not work with void (before C++1z).

Parameters
codeWhat we want to do
promiseWhere to want to store the result

◆ fulfillPromise() [1/2]

template<class R , class F >
auto simgrid::xbt::fulfillPromise ( R &  promise,
F &&  code 
) -> decltype(promise.set_value(code()))

◆ fulfill_promise() [2/2]

template<class P , class F >
auto simgrid::xbt::fulfill_promise ( P &  promise,
F &&  code 
) -> decltype(promise.set_value())

◆ fulfillPromise() [2/2]

template<class P , class F >
auto simgrid::xbt::fulfillPromise ( P &  promise,
F &&  code 
) -> decltype(promise.set_value())

◆ set_promise()

template<class P , class F >
void simgrid::xbt::set_promise ( P &  promise,
F &&  future 
)
inline

Set a promise/result from a future/result.

Roughly this does:

promise.set_value(future);

but it takes care of exceptions and works with void.

We might need this when working with generic code because the trivial implementation does not work with void (before C++1z).

Parameters
promiseoutput (a valid future or a result)
futureinput (a ready/waitable future or a valid result)

◆ setPromise()

template<class P , class F >
void simgrid::xbt::setPromise ( P &  promise,
F &&  future 
)
inline

◆ install_exception_handler()

void simgrid::xbt::install_exception_handler ( )

◆ logException()

void simgrid::xbt::logException ( e_xbt_log_priority_t  priority,
const char *  context,
std::exception const &  exception 
)

◆ installExceptionHandler()

void simgrid::xbt::installExceptionHandler ( )

◆ replay_runner()

int simgrid::xbt::replay_runner ( int  argc,
char *  argv[] 
)

◆ errno_category()

const std::error_category& simgrid::xbt::errno_category ( )
inlinenoexcept

A error_category suitable to be used with errno

It is not clear which error we are supposed to generate when getting a errno:

  • system_error clearly cannot be used for this on Windows;
  • generic_error might not be used for non-standard errno.

Let's just define a function which gives us the correct category.

◆ errno_code() [1/2]

std::error_code simgrid::xbt::errno_code ( int  errnum)
inline

Create a error_code from an errno value.

This is expected to to whatever is right to create a error_code from a given errno value.

◆ errno_code() [2/2]

std::error_code simgrid::xbt::errno_code ( )
inline

Create an error_code from errno (and clear it)

◆ errno_error() [1/4]

std::system_error simgrid::xbt::errno_error ( int  errnum)
inline

Create a system_error from an errno value.

This is expected to to whatever is right to create a system_error from a given errno value.

◆ errno_error() [2/4]

std::system_error simgrid::xbt::errno_error ( int  errnum,
const char *  what 
)
inline

◆ errno_error() [3/4]

std::system_error simgrid::xbt::errno_error ( )
inline

Create a system_code from errno (and clear it)

◆ errno_error() [4/4]

std::system_error simgrid::xbt::errno_error ( const char *  what)
inline

◆ intrusive_erase()

template<class List , class Elem >
void simgrid::xbt::intrusive_erase ( List &  list,
Elem &  elem 
)
inline

Erase an element given by reference from a boost::intrusive::list.

Variable Documentation

◆ demangle

std::unique_ptr<char, void (*)(void*)> simgrid::xbt::demangle(const char *name)

Try to demangle a C++ name.

Return the origin string if this fails.

◆ action_fs

std::ifstream* simgrid::xbt::action_fs