inherited template constructor not called - c++

Question

I am researching a design for a project and I have an issue to overcome. Basically I need the template constructor of visitor_interfaces_t to be called. Below is a simplified example of how the system works syntactically. The "large scale" project is located at https://github.com/amatarazzo777/ux_gui_stream and is in development by myself. The objects are organized to be easily created and also maintained. So I do like the syntax of how coordinate_t is written. However, it is not functioning as I planned. What is the proper way to inherit visitor_interfaces_t and allow the template param pack constructor to it to be called? C++17 dialect. Any other rigorous dissection is also welcomed, such as better design. Thanks in advance for help.
I did find another solution to this question. I decided to break up the process of broadcasting the interface position and resolving the member function to the implementation.
template header file (templates_inherit.h)
/**
templates_inherit.h
*/
#ifndef TEMPLATES_INHERIT_H_
#define TEMPLATES_INHERIT_H_
typedef int cairo_t;
typedef double PangoLayout;
class system_base_t {
public:
system_base_t() {
if (!visitor_dispatch_bound)
;
}
virtual ~system_base_t() {}
bool visitor_dispatch_bound = false;
};
template <typename T, typename TC, typename... Args>
class class_storage_emitter_t : public TC,
public Args...,
public system_base_t {
public:
using TC::TC;
class_storage_emitter_t() {}
class_storage_emitter_t(const class_storage_emitter_t &other) : TC(other) {}
class_storage_emitter_t(class_storage_emitter_t &&other) noexcept
: TC(other) {}
class_storage_emitter_t &operator=(const class_storage_emitter_t &other) {
TC::operator=(other);
return *this;
}
class_storage_emitter_t &operator=(class_storage_emitter_t &&other) noexcept {
TC::operator=(other);
return *this;
}
virtual ~class_storage_emitter_t() {}
};
typedef std::function<void(cairo_t *)> fn_emit_cr_t;
typedef std::function<void(PangoLayout *)> fn_emit_layout_t;
typedef std::variant<std::monostate, fn_emit_cr_t, fn_emit_layout_t>
fn_emit_overload_t;
class visitor_interface_t {
public:
fn_emit_overload_t fn = {};
std::size_t pipeline_order = {};
virtual void bind_dispatch(system_base_t *ptr) {}
};
class visitor_interfaces_base_t {
public:
visitor_interfaces_base_t() {}
virtual ~visitor_interfaces_base_t() {}
std::unordered_map<std::type_index, visitor_interface_t *>
accepted_interfaces = {};
};
template <typename... Args>
class visitor_interfaces_t : public visitor_interfaces_base_t, public Args... {
public:
visitor_interfaces_t() : Args(this)... {}
};
// abstract classes. started having problems when I added
// "interface" function (clue)
template <std::size_t ORDER> class abstract_emit_cr_t : visitor_interface_t {
public:
abstract_emit_cr_t(visitor_interfaces_base_t *ptr) {
pipeline_order = ORDER;
ptr->accepted_interfaces[std::type_index(typeid(fn_emit_cr_t))] = this;
}
void bind_dispatch(system_base_t *ptr) {
fn = fn_emit_cr_t{std::bind(&abstract_emit_cr_t::emit,
dynamic_cast<abstract_emit_cr_t *>(ptr),
std::placeholders::_1)};
}
virtual ~abstract_emit_cr_t() {}
virtual void emit(cairo_t *cr) = 0;
};
template <std::size_t ORDER>
class abstract_emit_layout_t : visitor_interface_t {
public:
abstract_emit_layout_t() {}
abstract_emit_layout_t(visitor_interfaces_base_t *ptr) {
pipeline_order = ORDER;
ptr->accepted_interfaces[std::type_index(typeid(fn_emit_layout_t))] = this;
}
void bind_dispatch(system_base_t *ptr) {
fn = fn_emit_layout_t{std::bind(&abstract_emit_layout_t::emit,
dynamic_cast<abstract_emit_layout_t *>(ptr),
std::placeholders::_1)};
}
virtual ~abstract_emit_layout_t() {}
virtual void emit(PangoLayout *layout) = 0;
};
const int order_render_option = 3;
class coordinate_storage_t {
public:
coordinate_storage_t() {}
coordinate_storage_t(double _x, double _y, double _w, double _h)
: x(_x), y(_y), w(_w), h(_h) {}
coordinate_storage_t(double _x, double _y) : x(_x), y(_y) {}
virtual ~coordinate_storage_t() {}
double x = {};
double y = {};
double w = {};
double h = {};
};
/**
* classes are named and manufactured like so.
* the parameterized nature of the syntax yields
* a very maintainable source base.
*/
using coordinate_t = class coordinate_t
: public class_storage_emitter_t<
coordinate_t, coordinate_storage_t,
visitor_interfaces_t<abstract_emit_cr_t<order_render_option>,
abstract_emit_layout_t<order_render_option>>> {
public:
using class_storage_emitter_t::class_storage_emitter_t;
coordinate_t() {}
void emit(cairo_t *cr) { std::cout << "emit cr" << std::endl; }
void emit(PangoLayout *layout) { std::cout << "emit layout" << std::endl; }
};
#endif /* TEMPLATES_INHERIT_H_ */
template_inherit.cpp
#include <functional>
#include <type_traits>
#include <typeindex>
#include <typeinfo>
#include <unordered_map>
#include <iostream>
#include <any>
#include <variant>
#include "templates_inherit.h"
using namespace std;
int main() {
coordinate_t pos = coordinate_t{10, 10, 500, 500};
pos.init_dispatch();
cout << pos.x << " " << pos.y << " " << pos.w << " " << pos.h << endl;
cairo_t dummy_cr = 1;
PangoLayout dummy_layout = 2;
for (auto n : pos.accepted_interfaces) {
std::visit(
[&](auto &&arg) {
using T = std::decay_t<decltype(arg)>;
if constexpr (std::is_same_v<T, fn_emit_cr_t>)
arg(&dummy_cr);
else if constexpr (std::is_same_v<T, fn_emit_layout_t>)
arg(&dummy_layout);
},
n.second->fn);
}
return 0;
}