ProcessLib::Graph::detail Namespace Reference

Classes
struct	GetFlattenedTupleOfPassedArgs
struct	GetFlattenedTupleOfPassedArgs< Result(*)(DeclaredArgs...), Tuples... >
struct	GetFlattenedTupleOfPassedArgs< Result(Class::*)(DeclaredArgs...) const, ClassAndPassedArgsTuples... >
struct	GetFlattenedTupleOfPassedArgs< Result(Class::*)(DeclaredArgs...), ClassAgain, PassedArgsTuples... >
struct	GetFlattenedTupleTypes
struct	GetFunctionArgumentTypes
struct	GetFunctionArgumentTypes< Result(*)(Args...)>
struct	GetFunctionArgumentTypes< Result(Class::*)(Args...) const >
struct	GetFunctionArgumentTypes< Result(Class::*)(Args...)>
struct	GetFunctionReturnType
struct	GetFunctionReturnType< Result(*)(Args...)>
struct	GetFunctionReturnType< Result(Class::*)(Args...) const >
struct	GetFunctionReturnType< Result(Class::*)(Args...)>
struct	IsInputArgument
struct	IsOutputArgument

Typedefs
template<typename Function >
using	GetFunctionArgumentTypesPlain

Functions
template<typename Object , typename... Tuples, typename... MemberFunctionArgumentTypesPlain>
auto	unpackAndInvoke (boost::mp11::mp_list< MemberFunctionArgumentTypesPlain... >, Object &&o, Tuples &... ts) -> typename GetFunctionReturnType< decltype(&std::decay_t< Object >::operator())>::type
template<typename Result , typename Object , typename... Args, typename... Tuples, typename... MemberFunctionArgumentTypesPlain>
Result	unpackAndInvoke (boost::mp11::mp_list< MemberFunctionArgumentTypesPlain... >, Result(Object::*m)(Args...), Object &o, Tuples &... ts)
template<typename Result , typename Object , typename... Args, typename... Tuples, typename... MemberFunctionArgumentTypesPlain>
Result	unpackAndInvoke (boost::mp11::mp_list< MemberFunctionArgumentTypesPlain... >, Result(Object::*m)(Args...), Object &&o, Tuples &... ts)
template<typename Result , typename Object , typename... Args, typename... Tuples, typename... MemberFunctionArgumentTypesPlain>
Result	unpackAndInvoke (boost::mp11::mp_list< MemberFunctionArgumentTypesPlain... >, Result(Object::*m)(Args...) const, Object const &o, Tuples &... ts)
template<typename Result , typename... Args, typename... Tuples, typename... FunctionArgumentTypesPlain>
Result	unpackAndInvoke (boost::mp11::mp_list< FunctionArgumentTypesPlain... >, Result(*fct)(Args...), Tuples &... ts)
template<typename Function , typename... Args>
auto	applyImpl (Function &&f, Args &&... args) -> typename detail::GetFunctionReturnType< std::decay_t< Function > >::type
template<typename Model >
bool	isEvalOrderCorrectRT (std::unordered_set< std::type_index > &computed_data)
template<typename... Models>
bool	isEvalOrderCorrectRT (boost::mp11::mp_list< Models... >, std::unordered_set< std::type_index > &&computed_data)
template<typename Model , typename TupleOfArgs >
Model	constructModel (TupleOfArgs &args)
template<template< typename... > typename Tuple, typename... Models, typename TupleOfArgs >
Tuple< Models... >	constructModels (std::type_identity< Tuple< Models... > >, TupleOfArgs &&args)
template<typename T , typename Tuple , typename... Tuples>
auto &	getImpl (Tuple &t, Tuples &... ts)

Typedef Documentation

GetFunctionArgumentTypesPlain

template<typename Function >

using ProcessLib::Graph::detail::GetFunctionArgumentTypesPlain

Initial value:

 
    std::type_identity<boost::mp11::mp_transform<
        std::remove_cvref_t,
        typename GetFunctionArgumentTypes<Function>::type>>

Definition at line 49 of file Apply.h.

Function Documentation

applyImpl()

template<typename Function , typename... Args>

auto ProcessLib::Graph::detail::applyImpl	(	Function &&	f,
		Args &&...	args ) -> typename detail::GetFunctionReturnType<std::decay_t<Function>>::type

Invokes the passed function f.

f can be a function object, a free function, or a member function pointer. In the latter case, the first entry of args must be the object for which f shall be invoked. (The remainder of) args are an arbitrary number of tuples from which arguments to f are taken based on their types.

See also

ProcessLib::Graph::apply()

Definition at line 220 of file Apply.h.

{
    using namespace boost::mp11;
 
    using FunctionPlain = std::decay_t<Function>;
    using FlattenedTuple =
        typename GetFlattenedTupleOfPassedArgs<FunctionPlain, Args...>::type;
    using FlattenedTupleOfPlainTypes =
        mp_transform<std::remove_cvref_t, FlattenedTuple>;
 
    static_assert(
        mp_is_set_v<FlattenedTupleOfPlainTypes>,
        "The types of all elements of all passed tuples must be unique.");
 
    using FunctionArgumentTypesPlain =
        typename detail::GetFunctionArgumentTypesPlain<FunctionPlain>::type;
 
    static_assert(
        mp_is_set_v<FunctionArgumentTypesPlain>,
        "The argument types of the function to be called must be unique.");
 
    return unpackAndInvoke(FunctionArgumentTypesPlain{},
                           std::forward<Function>(f),
                           std::forward<Args>(args)...);
}

References unpackAndInvoke().

Referenced by ProcessLib::Graph::apply(), constructModel(), and ProcessLib::Graph::eval().

constructModel()

template<typename Model , typename TupleOfArgs >

Model ProcessLib::Graph::detail::constructModel

(

TupleOfArgs &

args

)

Definition at line 29 of file ConstructModels.h.

{
    if constexpr (HasCreate<Model>)
    {
        return applyImpl(&Model::create, args);
    }
    else if constexpr (std::is_default_constructible_v<Model>)
    {
        return Model{};
    }
    else
    {
        static_assert(std::is_default_constructible_v<
                          Model> /* This is definitely false, here. */,
                      "The model to be constructed has neither a static "
                      "create() function nor is it default constructible.");
    }
}

References applyImpl().

constructModels()

template<template< typename... > typename Tuple, typename... Models, typename TupleOfArgs >

Tuple< Models... > ProcessLib::Graph::detail::constructModels	(	std::type_identity< Tuple< Models... > >	,
		TupleOfArgs &&	args )

Definition at line 50 of file ConstructModels.h.

{
    return Tuple{constructModel<Models>(args)...};
}

Referenced by ProcessLib::Graph::constructModels().

getImpl()

template<typename T , typename Tuple , typename... Tuples>

auto & ProcessLib::Graph::detail::getImpl	(	Tuple &	t,
		Tuples &...	ts )

Definition at line 21 of file Get.h.

{
    using namespace boost::mp11;
 
    using PlainTuple = std::remove_cv_t<Tuple>;
    using TupleOfPlainTypes = mp_transform<std::remove_cvref_t, PlainTuple>;
    using Index = mp_find<TupleOfPlainTypes, T>;
 
    if constexpr (Index::value != mp_size<PlainTuple>::value)
    {
        return std::get<Index::value>(t);
    }
    else
    {
        return getImpl<T>(ts...);
    }
}

isEvalOrderCorrectRT() [1/2]

template<typename... Models>

bool ProcessLib::Graph::detail::isEvalOrderCorrectRT	(	boost::mp11::mp_list< Models... >	,
		std::unordered_set< std::type_index > &&	computed_data )

Definition at line 98 of file CheckEvalOrderRT.h.

{
    return (isEvalOrderCorrectRT<Models>(computed_data) && ...);
}

isEvalOrderCorrectRT() [2/2]

template<typename Model >

bool ProcessLib::Graph::detail::isEvalOrderCorrectRT

(

std::unordered_set< std::type_index > &

computed_data

)

Definition at line 45 of file CheckEvalOrderRT.h.

{
    using namespace boost::mp11;
 
    using ModelArgs =
        typename GetFunctionArgumentTypes<decltype(&Model::eval)>::type;
    using ModelInputs = mp_filter<IsInputArgument, ModelArgs>;
    using ModelOutputs = mp_filter<IsOutputArgument, ModelArgs>;
 
    using ModelInputsWrapped = mp_transform<mp_identity, ModelInputs>;
 
    // Check that all inputs have already been computed before.
    bool all_inputs_computed = true;
    mp_for_each<ModelInputsWrapped>(
        [&computed_data,
         &all_inputs_computed]<typename Input>(mp_identity<Input>)
        {
            if (!computed_data.contains(std::type_index{typeid(Input)}))
            {
                ERR("Input {} of model {} has not been computed/set before the "
                    "model evaluation.",
                    typeid(Input).name(), typeid(Model).name());
                all_inputs_computed = false;
            }
        });
    if (!all_inputs_computed)
    {
        return false;
    }
 
    using ModelOutputsWrapped = mp_transform<mp_identity, ModelOutputs>;
 
    // All outputs are "computed data", now.
    bool no_output_precomputed = true;
    mp_for_each<ModelOutputsWrapped>(
        [&computed_data,
         &no_output_precomputed]<typename Output>(mp_identity<Output>)
        {
            auto const [it, emplaced] = computed_data.emplace(typeid(Output));
 
            if (!emplaced)
            {
                ERR("Output {} of model {} is computed more than once.",
                    typeid(Output).name(),
                    typeid(Model).name());
                no_output_precomputed = false;
            }
        });
 
    return no_output_precomputed;
}

References ERR().

Referenced by ProcessLib::Graph::isEvalOrderCorrectRT().

unpackAndInvoke() [1/5]

template<typename Result , typename... Args, typename... Tuples, typename... FunctionArgumentTypesPlain>

Result ProcessLib::Graph::detail::unpackAndInvoke	(	boost::mp11::mp_list< FunctionArgumentTypesPlain... >	,
		Result(*)(Args...)	fct,
		Tuples &...	ts )

Definition at line 155 of file Apply.h.

{
    return fct(ProcessLib::Graph::get<FunctionArgumentTypesPlain>(ts...)...);
}

unpackAndInvoke() [2/5]

template<typename Object , typename... Tuples, typename... MemberFunctionArgumentTypesPlain>

auto ProcessLib::Graph::detail::unpackAndInvoke	(	boost::mp11::mp_list< MemberFunctionArgumentTypesPlain... >	,
		Object &&	o,
		Tuples &...	ts ) -> typename GetFunctionReturnType< decltype(&std::decay_t<Object>::operator())>::type

Definition at line 91 of file Apply.h.

{
    return o(
        ProcessLib::Graph::get<MemberFunctionArgumentTypesPlain>(ts...)...);
}

Referenced by applyImpl().

unpackAndInvoke() [3/5]

template<typename Result , typename Object , typename... Args, typename... Tuples, typename... MemberFunctionArgumentTypesPlain>

Result ProcessLib::Graph::detail::unpackAndInvoke	(	boost::mp11::mp_list< MemberFunctionArgumentTypesPlain... >	,
		Result(Object::*)(Args...) const	m,
		Object const &	o,
		Tuples &...	ts )

Definition at line 140 of file Apply.h.

{
    return (o.*m)(
        ProcessLib::Graph::get<MemberFunctionArgumentTypesPlain>(ts...)...);
}

unpackAndInvoke() [4/5]

template<typename Result , typename Object , typename... Args, typename... Tuples, typename... MemberFunctionArgumentTypesPlain>

Result ProcessLib::Graph::detail::unpackAndInvoke	(	boost::mp11::mp_list< MemberFunctionArgumentTypesPlain... >	,
		Result(Object::*)(Args...)	m,
		Object &&	o,
		Tuples &...	ts )

Definition at line 124 of file Apply.h.

{
    return (o.*m)(
        ProcessLib::Graph::get<MemberFunctionArgumentTypesPlain>(ts...)...);
}

unpackAndInvoke() [5/5]

template<typename Result , typename Object , typename... Args, typename... Tuples, typename... MemberFunctionArgumentTypesPlain>

Result ProcessLib::Graph::detail::unpackAndInvoke	(	boost::mp11::mp_list< MemberFunctionArgumentTypesPlain... >	,
		Result(Object::*)(Args...)	m,
		Object &	o,
		Tuples &...	ts )

Definition at line 108 of file Apply.h.

{
    return (o.*m)(
        ProcessLib::Graph::get<MemberFunctionArgumentTypesPlain>(ts...)...);
}