Unifikacja getBin() w binning policies

[saganatt]

https://github.com/AliceO2Group/AliceO2/blob/dev/Framework/Core/include/Framework/BinningPolicy.h
Różnica jest na poziomie templates.

FlexibleBinningPolicy:

template <typename... T2s>
int getBin(std::tuple<T2s...> const& data) const

ColumnBinningPolicy:

int getBin(std::tuple<typename Ts::type...> const& data) const

NoBinningPolicy:

int getBin(std::tuple<typename C::type> const& data) const

Z perspektywy użytkownika różnica jest taka, że można napisać:

int bin = myColumnBinning.getBin(collision1.posZ(), multiplicity);

Ale przy flexible binning trzeba jawnie napisać std::tuple:

int bin = myFlexibleBinning.getBin(std::tuple(collision1.posZ(), multiplicity));

Bez napisania explicite std::tuple użytkownicy dostają ścianę tekstu z błędu kompilacji:

cannot convert '<brace-enclosed initializer list>' to 'const std::tuple<>&

I kompilator uważa, że T2s = {}, tj. nie rozpoznaje, że typy posZ i multiplicity (float i float) to miały być T2s.
W innych binning policies typy argumentów getBin są dedukowane z typów w template klasy, dlatego kompilator się na nich nie wywala.

Możecie w naprawionych tutorialach napisać taska na to (jakby unit test), i zobaczyć, jak wygląda błąd kompilacji.

Pytanie, czy możemy pozbyć się tego template <typename... T2s>, czyli napisać, jakie mają być typy argumentów getBin() na podstawie Ts... z szablonu klasy. To zadanie może wymagać od was większej akrobacji z templates, gdyż Ts... w FlexibleBinning to pomieszane typy kolumn i typy funkcji lambda.
Zostawię Wam do przemyślenia, możemy się spotkać po weekendzie i to omówić.

[MykhailoShamrai]

Dodatkowy opis problemu:

"ściślej: w template są typy kolumn i typy lambd

I jest ogólna deklaracja w linii 229, która nie prowadzi do niczego.

A następnie, specjalizacja template w linii 233, która bierze typy kolumn i lambd do krotki typów lambd i do typów kolumn.

To musiało być tak pokracznie zrobione, żeby kompilator C++ to skompilował.

I teraz w Flexible Policy getBin jest dodatkowo template'owane pomocniczymi typami T2s, które oznaczają typy danych w tuplu.

Założenie (nie sprawdzane tutaj nigdzie) jest takie, że te typy odpowiadają kolejno typom wartości zwracanych przez lambdy i/lub typom danych zawartych w kolumnach.

Łatwiej to widać w wersji Column Policy, gdzie w getBin mam napisane Ts::type -- Ts to typy kolumn, każda kolumna ma wewnątrz zadeklarowany typ type na typ przechowywanych danych (float, int itd.). Więc tu dało się jawnie napisać, że spodziewam się tupla zawierającego dane o typach kolejno odpowiadających typom danych z kolumn, którymi klasa jest template'owana.

I teraz główny problem jest w tym, czy w przypadku Flexible Policy jesteśmy w stanie wymyśleć C++ magię, która wydedukuje i typy zwracane przez lambdy, i typy danych kolumn, i umieści te typy w odpowiedniej kolejności w deklaracji getBin(). Tak, byśmy nie musieli używać dodatkowego template z T2s."

To do czego udało się dojść w tym momenci odnośnie sprawdzania typów zwracanych - to to że jest to możliwe w czasie kompilacji.

class A {
public:
int I;

A(int i = 1): I(i){};
};

int main(void)
{
auto a = [](int x){return A();};
auto b = []() {return A(2);};

static_assert(std::is_same_v<std::invoke_result_t<decltype(a), int>, std::invoke_result_t<decltype(b)>>); 

Taki kod na przykład w czasie kompilacji sprawdza, czy dwie lambdy zwracają to samo, może być to przydatne w tym zadaniu,

Te invoke_result_t w czasie kompilacji wydedykowuje typ zwracany przez lambdę.