struct Int32
{
    using Type = int32_t; // стандартный базовый тип
    template<typename T> static void Encoder(Buffer *buffer, Size &pos, T value)
    {
        impl::EncoderPOD<Type>(buffer, pos, value);
    }
    static void Decoder(const Buffer *buffer, Size &pos, Type &value)
    {
        impl::DecoderPOD<Type>(buffer, pos, value);
    }
    static constexpr auto Signature() { /*...*/ }
    static constexpr const char *Name() { return "NInt32"; }
};
// Аналогично написаны кодеки для всех стандартных типов (почти для всех :) ) 
// ...

// Кодирование пакета значений в буфер
template<typename ...TEncoders>
Buffer *Encode(Buffer *buffer, typename TEncoders::Type... vals) { /*...*/ }

// Декодирование произвольного количества значений из буфера
template<typename ...TDecoders>
const Buffer *Decode(const Buffer *buffer, typename TDecoders::Type&... vals)  { /*...*/ }

class Input
{
    public:
        // Активизация входа(вызов функции, связанной с входом) 
        // buffer - буфер с закодированными параметрами, куда также записывается возвращаемое значение
        virtual void Call(Buffer *buffer)const=0;
        virtual const Signature *GetSignature()const=0; // получение сигнатуры входа
};
template<typename TComponentType, typename TRetCodec, typename ...TArgsCodec>
class ComponentInput : public Input
{
    private:
        using TRet = typename TRetCodec::Type; // тип возвращаемого значения
        // тип указателя на функцию-член
        using TMemberFunction = TRet (TComponentType::*)(typename TArgsCodec::Type...); 
        TMemberFunction _funcMember; // указатель на функцию член-компонента

    public:
        ComponentInput(TMemberFunction funcMember)
              : _funcMember(funcMember) {}
              
        void Call(Buffer *buffer)const
        {
            std::tuple<typename TArgsCodec::Type...> t_args;
            std::apply([buffer, &_func=_func](auto ...args)
            {
                // Декодирование указателя на компонент и аргументов args из буфера buffer
                uint64_t com;
                Decode<Uint64, TArgsCodec...>(buffer, com, args...);
                if constexpr(std::is_void<TRet>::value) // если функция возвращает void
                    (((TComponentType*)com)->*_funcMember)(args...); // вызов функции входа без обработки возвращаемого значения
                // вызов функции входа и кодирование возвращаемого значения в буфер (возврат результата через буфер параметров)
                else Encode<TRetCodec>(buffer, (((TComponentType*)com)->*_funcMember)(args...));
            }, t_args);
        }
        const Signature *GetSignature()const {/*...*/}
};

class Output
{
    public:
        virtual void Bind(Component *com, Input *input)=0;
};
template<typename TRetCodec, typename ...TArgsCodec>
class ComponentOutput : public Output
{
    private:
        using TRet = typename TRetCodec::Type;
        Component *_com;
        Input *_input;

    public:
        void Bind(Component *com, Input *input) // Связывание
        {
            // Проверка сигнатур
            // ...
            _com = com;
            _input = input;
        }
        TRet Call(typename TArgsCodec::Type... args)
        {
            Buffer buffer[PARAMS_BUF_SIZE]; // буфер для параметров
            // кодирование адреса компонента и параметров, вызов входа
            _input->Call(Encode<UInt64, TArgsCodec...>(buffer, _com, args...)); 
            return DecodeValue<TRetCodec>(buffer);  // декодирование возвращаемого значения
        }
};

class MyComponent : public Component
{
    // ...
    constexpr static auto _tinputs{make_tuple(
        ComponentInput<Void, Void>(&MyComponent::f1),
        ComponentInput<Uint32, Int8>(&MyComponent::f2)
        // ...
    )};
    // ...
    ComponentOutput<Void, Void> func1;
    ComponentOutput<Uint32, Int8> func2;
    // ...
};