Meet two generic values in one function - c++

Question

I have two callbacks foo and bar, both taking a generic value each.
When both callbacks has been called I want these values to meet in single function. My test code is:
template <class FooType, class BarType>
void meet_point(FooType foo_value, BarType bar_value) {
// Success
}
struct test
{
template <class FooType>
void foo(FooType value) {
// TODO: save value or type somehow
}
template <class BarType>
void bar(BarType value) {
meet_point(/* FooType value from above */, value);
}
};
template <class F>
void sync_request(F&& f) {
f("foobar");
}
int main()
{
test t;
sync_request([&t](auto value) {
t.foo(value);
});
t.bar(42);
}
Is there any way to do it?
EDIT:
Note that code in main() is just an example of calling both callbacks. Actual calls happens from different places and both triggers do not know anything about each other.
Also at the time of instantiating test object no type is known ahead. Actually test struct is not even needed here. It could be standalone callbacks. It is there just for maybe possible storage of FooType value.
P.S.
I wish we had reflection, jit, Circle #type_id or templated virtual functions to extract the type in C++.

Answer 1

You need to know (or be able to exhaustively list the possibilities of) at least one of FooType or BarType.
Case 1: FooType is one of typename... FooTypes known when you instantiate a test.
template<typename... FooTypes>
struct test
{
using FooType = std::variant<FooTypes...>;
void foo(FooType value) {
foo_value = value;
}
template <class BarType>
void bar(BarType value) {
std::variant<BarType> bar_value = value;
std::visit(meet_point, foo_value, bar_value);
}
FooType foo_value;
};
Case 2: BarType is one of typename... BarTypes known when you instantiate a test.
template<typename... BarTypes>
struct test
{
using BarType = std::variant<BarTypes...>;
template <class FooType>
void foo(FooType value) {
std::variant<FooType> foo_value = value;
visit = [foo_value](BarType bar_value){ std::visit(meet_point, foo_value, bar_value); };
}
void bar(BarType value) {
visit(value)
}
function<void(std::variant<BarTypes...>)> visit;
};
Case 3: FooType is one of typename... FooTypes and BarType is one of typename... BarTypes, both known when you instantiate a test.
template<typename... FooTypes, typename... BarTypes>
struct test
{
using FooType = std::variant<FooTypes...>;
using BarType = std::variant<BarTypes...>;
void foo(FooType value) {
foo_value = value;
}
void bar(BarType bar_value) {
std::visit(meet_point, foo_value, bar_value);
}
std::variant<FooTypes...> foo_value;
};

Answer 2

When you write your code you do not know which types the user of your library will use. But when the user compiles his types has to be known. If you are fine with letting the user register his types you can do it like this:
#include <boost/algorithm/algorithm.hpp>
#include <boost/algorithm/string.hpp>
#include <boost/hana.hpp>
#include <functional>
#include <iostream>
#include <type_traits>
// code you write
struct CallbackData
{
virtual ~CallbackData () = default;
};
// code your user writes for example in userTypes.h
struct TestFooType : CallbackData
{
int value = 42;
};
struct TestBarType : CallbackData
{
std::string value{ "bar type" };
};
struct AnotherTestFooType : CallbackData
{
int value = 42;
};
struct AnotherTestBarType : CallbackData
{
std::string value{ "bar type" };
};
static boost::hana::tuple<TestFooType, TestBarType, AnotherTestFooType, AnotherTestBarType> const sharedClasses{};
// code you write
struct test
{
void
bothAreReady ()
{
boost::hana::for_each (sharedClasses, [&] (auto x) {
if (std::shared_ptr<std::decay_t<decltype (x)>> firstValue = std::dynamic_pointer_cast<std::decay_t<decltype (x)>> (fooValue))
{
std::cout << "fooValue: " << firstValue->value << std::endl;
return;
}
});
boost::hana::for_each (sharedClasses, [&] (auto x) {
if (std::shared_ptr<std::decay_t<decltype (x)>> secondValue = std::dynamic_pointer_cast<std::decay_t<decltype (x)>> (barValue))
{
std::cout << "barValue: " << secondValue->value << std::endl;
return;
}
});
}
bool
isDone ()
{
return fooValue && barValue;
}
std::shared_ptr<CallbackData> fooValue{};
std::shared_ptr<CallbackData> barValue{};
};
// code your user writes
int
main ()
{
test t;
auto fooAction = [&t] () {
auto testFooType = TestFooType{};
// do something with test foo type
t.fooValue = std::shared_ptr<CallbackData>{ new std::decay_t<decltype (testFooType)>{ std::move (testFooType) } };
if (t.isDone ()) t.bothAreReady ();
};
auto barAction = [&t] () {
auto testBarType = TestBarType{};
// do something with testBarType
t.barValue = std::shared_ptr<CallbackData>{ new std::decay_t<decltype (testBarType)>{ std::move (testBarType) } };
if (t.isDone ()) t.bothAreReady ();
};
// run the lambdas on some other thread or so
fooAction ();
barAction ();
}
wandbox example

Answer 3

Alice live in Australia. Alice creates a nice class Alice, writes a source file that contains a call to test.foo(Alice()), builds a DLL, and ships it to you.
Bob lives in Bermuda. Bob creates a nice class Bob, writes a source file that contains a call to test.bar(Bob()), builds a DLL, and ships it to you.
Alice and Bob have never heard of each other and have never seen each other's code.
You have your program load the two DLLs and...
Where is meet_point<Alice, Bob>?
It cannot be in Alice's DLL, because Alice have never seen Bob's code.
It cannot be in Bob's DLL, because Bob have never seen Alice's code.
It cannot be in your program, because you have never seen the code of either of them! All you have is their DLL that call your code. They both obviously have your header that defines struct test, but this doesn't help at all.
So you need some tool that would go over Alice's and Bob's code, extract all types that are used in calls to foo and bar, and instantiate meet_point<a, b> with every possible pair (a, b) of such types. The problem is, there isn't such tool in any standard toolkit. You need to write one somehow.
The easiest way would be asking Alice and Bob to send you a list of their types used in calls to foo and bar. You can also go over their object code and extract these types from symbols or whatever. In any case you need them to send you header files with definitions of all their classes, so that you can compile each instantiation. Another option (not as crazy as it sounds) would be just-in-time compilation: make your class find the headers (you can know the names of the classes so that's doable), generate a source that instantiates meet_point with relevant arguments, run the compiler, build a DLL, load it, and call the function! Cache the DLL for later use. Of course it could happen that meet_point cannot be compiled with a particular combination of arguments, and you will only know it when this combination arrives.
Now "two developers that do not talk to each other send you DLLs" is an extreme model of the situation, but it doesn't actually create any new problem. It just makes it easier to see problems that are inherent in the situation.