C++17, Tuples, Folding hier möglich?

[cppbert3 (Gast)]

wieder mal ein sehr grosses Beispiel :/
aber vielleicht hat ja jemand eine Idee wie das gehen könnte

bisher wird der Code in make_from_c_params generiert
aber ich würde gerne den Code schlanker und weniger if/else/return 
lastiger machen - damit mein Haufen Boilerplate-Code schön klein bleibt 
:)

ich habe versucht das ganze ein wenig Template/Deklarativer zu machen - 
mir gehen aber die verrückten Ideen aus :-/

Es geht mir hier nur um eine Machbarkeit - nicht das ich da auf Teufel 
komm raus von abhängig bin - aber die Situation mit der C-Schnittstelle 
und den Error-Codes usw. ist schon sehr realistisch und kann von mir 
auch nicht verändert werden

gcc.godbolt: https://gcc.godbolt.org/z/zE7154

#include <vector>
#include <tuple>
#include <string>

class Test
{
private:
    Test() = default;

public:
    // "C"-Interface

    int set_id( int id_ )
    {
        m_id = id_;
        return 0;
    }

    int set_xyz( int* xyz_values_, int xyz_size_ )
    {
        if( !xyz_values_ )
        {
            return 1;
        }
        m_xyz = { xyz_values_, xyz_values_ + xyz_size_ };
        return 0;
    }

    int set_name( const char* name_ )
    {
        if( !name_ )
        {
            return 1;
        }
        m_name = name_;
        return 0;
    }

    struct result
    {
        int code{};
        Test* instance{};
    };

    //=================================
    // ab hier meine neuen Ideen

    friend struct create_instance;

    template <auto Set, typename... Values>
    struct setter
    {
        setter( Values&&... values_ ) : m_values( values_... )
        {
        }
        std::tuple<Values...> m_values;
    };

    template <typename InstanceType, typename... Setter>
    struct create_instance
    {
        create_instance( std::tuple<Setter...> setter_ ) : m_setter( setter_ )
        {
        }

        result operator()() const
        {
            auto instance = new Test();

            return { 0, instance };
        }
        std::tuple<Setter...> m_setter;
    };

    // bis hier - im #if 0 versuche ich das ganzen Aufzurufen scheitere aber
    // an den Parametern
    //=================================

    static result make_from_c_params( int id_, int* xyz_values_, int xyz_count, const char* name_ )
    {
#if 0 // ich scheitere ein wenig an den Details :/
        using ci = create_instance<Test, 
            setter<&Test::set_id>, 
            setter<&Test::set_xyz>, 
            setter<&Test::set_name>>;
        return ci({})();
        /*
        return create_instance<...>(instance,
        {
            {&Test::set_id, {id_}, -1}
            {&Test::set_xyz, {xyz_values_, xyz_count}, -2}
            {&Test::set_name, {name_}, -3}
        }
        );
        */
#else
        // dieser Code wird generiert (nur mit unique_ptr, usw.)
        auto instance = new Test();

        if( auto result = instance->set_id( id_ ) != 0 )
        {
            return { -1, {} };
        }

        if( auto result = instance->set_xyz( xyz_values_, xyz_count ) != 0 )
        {
            return { -2, {} };
        }

        if( auto result = instance->set_name( name_ ) != 0 )
        {
            return { -3, {} };
        }

        return { 0, instance };
#endif
    }

    int m_id{};
    std::vector<int> m_xyz;
    std::string m_name;
};

int main()
{
    int id = 12;
    std::vector<int> xyz{ 1, 2, 3 };
    std::string name = "hello";
    auto t = Test::make_from_c_params( id, xyz.data(), xyz.size(), name.c_str() );
    return 0;
}