create_at with uvalue parameters

[MineBill]

How would i go about calling create_at on a constructor but passing runtime uvalue parameters? Obviously ,create_at(value) where value is a uvalue won't work because it will try to call a T::T(uvalue) constructor, which i don't want.

[BlackMATov]

Hi! It depends a lot on what you want to get in the end and what exactly is stored in this 'uvalue' on the memory of which you want to call a constructor. I would not recommend getting involved with this slippery topic and just recreate the 'uvalue' using the common 'create' function.

But if you really want to get UB or something worse, 'uvalue' has a 'get_data' method that will return a pointer to the raw data.

[MineBill]

Thanks for your answer but I made a mistake while typing my question 🙃. I meant to use the plain create method, instead of create_at. To reiterate my question with this edit, I know the ctor takes one parameter, I know that it is of the same type as the uvalue contents and now I want to call the ctor with the contents of the uvalue without performing any explicit type casting.

[BlackMATov]

Before we get completely confused, show the code where you register the constructor, where you try to call it and how, plz :-)

[MineBill]

I'm sorry. I've been trying to get minimal example going and i realized that i f'ed up somewhere in my original code and what i'm trying to do works. In any case, here is the code:

#include <https://raw.githubusercontent.com/BlackMATov/meta.hpp/refs/heads/main/develop/singles/headers/meta.hpp/meta_all.hpp>
#include <print>
#include <cassert>

struct S
{
    explicit S(int number)
        : Number(number)
    {
        // do something with number
    }

    explicit S(std::string s)
    {
        std::println("I got {}", s);
    }

    int Number;
};

meta_hpp::uresult ConstructItem(meta_hpp::constructor ctor, meta_hpp::uvalue value)
{
    // ASSERT(ctor.get_arity() == 1);
    // ASSERT(ctor.get_argument(0).get_type() == value.get_type());
    // Do additional things.

    // In my original code, passing a uvalue here caused an argument mismatch
    // so I assumed that because the `*create*` functions are templated, passing a
    // uvalue (and not a literal) would try to call the constructor like this `S::S(meta::uvalue)`.
    // But since this clearly works, I probably messed something up and didn't pass a uvalue
    // with the correct type.
    return ctor.try_create(value);
}

meta_hpp::uvalue MakeValue(int i)
{
    switch (i)
    {
    case 0:
        return true;
    case 1:
        return 2.0f;
    case 2:
        return std::string("ad");
    default:
        return 0;
    }
}

int main()
{
    meta_hpp::class_<S>()
        .constructor_<int>()
        .constructor_<std::string>();

    auto type = meta_hpp::resolve_type<S>();

    assert(ConstructItem(type.get_constructors().at(0), MakeValue(99)).has_value());
    assert(ConstructItem(type.get_constructors().at(0), MakeValue(1)).has_error());
    assert(ConstructItem(type.get_constructors().at(1), MakeValue(2)).has_value());
}

[BlackMATov]

The main nuance that should be taken into account with overloaded methods and constructors is that the library does not support the correct determination of the required overload based on the parameters passed. In this regard, the library will simply try to call available constructors one by one until it succeeds.

You can get a suitable constructor using the get_constructor_with method which will try to find a constructor with the required parameters (without conversion), or just call create to try to call them one by one. It's up to you.

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

#include <https://raw.githubusercontent.com/BlackMATov/meta.hpp/refs/heads/main/develop/singles/headers/meta.hpp/meta_all.hpp>

#include <print>
#include <string>
#include <utility>

struct S
{
    explicit S(int n)
    {
        std::println("I got {}", n);
    }

    explicit S(std::string s)
    {
        std::println("I got {}", s);
    }
};

namespace meta = meta_hpp;

int main()
{
    meta_hpp::class_<S>()
        .constructor_<int>()
        .constructor_<std::string>();

    auto type = meta::resolve_type<S>();

    {
        // calls ctors one by one until success
        std::ignore = type.create(meta::uvalue{std::string("hello")});
        std::ignore = type.create(meta::uvalue{42});
    }

    {
        // finds ctor by static types
        std::ignore = type.get_constructor_with<std::string>().create(meta::uvalue{std::string("hello")});
        std::ignore = type.get_constructor_with<int>().create(meta::uvalue{42});
    }

    {
        // finds ctor by ilist of dynamic types
        meta::uvalue arg = std::string("hello");
        std::ignore = type.get_constructor_with({arg.get_type()}).create(arg);
    }
}

P.S.

I also just realized that create methods should not be marked as nodiscard, hah. :-)

[MineBill]

Yeah now that I realized how it works everything makes sense and the actual code I was working on works as expected. It was mostly the wrong assumption on my part that stopped me.