// aktuelle VS2017 Version, oder GCC 8.2, C++14 oder C++17 waere moeglich
#include <tuple>
#include <vector>
#include <cassert>
template<typename Value>
struct in_parameter_t
{
in_parameter_t(void* value) {}
};
template<typename Value>
struct out_parameter_t
{
out_parameter_t(void* value) {}
};
template<typename Value>
struct inout_parameter_t
{
inout_parameter_t(void* value) {}
};
template<typename ValueType>
struct parameter_type_t {};
template<>
struct parameter_type_t<int>
{
using type = in_parameter_t<int>;
};
template<>
struct parameter_type_t<int&>
{
using type = inout_parameter_t<int>;
};
using parameter_t = std::vector<void*>;
/*
// Versuch Frage 2 zu beantworten - aber ausser viele viele Varianten von Kompilefehler komme ich da nicht weiter
namespace detail
{
template <typename TupleType_TP, size_t... Indices_TPs>
auto get_parameter(parameter_t& parameter, std::index_sequence<Indices_TPs...>)
{
//return TupleType_TP(parameter[Indices_TPs]...);
return TupleType_TP({ nullptr, nullptr });
}
}
template <typename... Types_TPs>
auto get_parameter(parameter_t& parameter)
{
return detail::get_parameter<std::tuple<Types_TPs...>>(parameter, std::index_sequence_for<Types_TPs...>());
}
*/
int main()
{
//------
// Kompilezeit-Parameter
// Methoden-Parameter-Typen
using native_parameter_types = std::tuple<int,int&>;
//------
// Laufzeit-Parameter
int p0 = 0;
int p1 = 0;
parameter_t parameter{&p0, &p1}; // muss ein std::vector sein (std::array ist zu fix)
// zur Laufzeit garantiert das zu jedem native_parameter_types[x] ein parameter[x] existiert
assert(parameter.size() == std::tuple_size<native_parameter_types>::value);
//------
// hier kommen mein Fragen
// aus dem nativen typ einen adapter typ erzeugen
using parameter_types_t = std::tuple
<
parameter_type_t<std::tuple_element<0, native_parameter_types>::type>::type,
parameter_type_t<std::tuple_element<1, native_parameter_types>::type>::type
>;
//====> FRAGE 1: geht das auch mit einer Template-Funktion?
//so in der Art?
//using parameter_types_t = get_parameter_types<native_parameter_types>::types;
// die adapter mit dem parameter-pointer instanzieren
auto p = parameter_types_t
(
parameter[0],
parameter[1]
);
//====> FRAGE 2: geht das auch mit einer Template-Funktion?
//so in der Art?
//auto p = get_parameter<parameter_types_t>(parameter);
return 0;
}
