Using std::vector<move-only-type> as a component

[jhasse]

I'm trying to wrap my head around having move-only types as components. Why does the following work

registry.emplace<std::unique_ptr<int>>(enemy, std::unique_ptr<int>());

but wrapping a move-only type in a std::vector results in 100 pages of error messages?

registry.emplace<std::vector<std::unique_ptr<int>>>(enemy, std::vector<std::unique_ptr<int>>());

[skypjack]

Can you post the relevant part of the error? I can't try it right away but I've a suspect.

[pinguin999]

You can try it here: https://godbolt.org/z/39K6e5nsc
It's only a problem with entt trunk. It's working with 3.6.0 on godbolt.

[skypjack]

Ahaaa I see it. Take a seat because this is a tricky one. 😅

The issue is the try_emplace function of the basic_storage class. This function is meant to make you assign entities to a storage from the base. That is, a sort of opaque emplace function.
For example, you can have a scripting system that looks up a storage class by name and invokes emplace on it without even knowning the actual type of the component.

The main problem is that here we also face an idiosyncrasy of the language. Because of that, we can't really get around your issue from within EnTT.
Let me explain why. Everything boils down to the following check (which is part of try_emplace):

if constexpr(std::is_copy_constructible_v<value_type>) {
    return emplace_element(entt, force_back, *static_cast<const value_type *>(value));
} else {
    return base_type::end();
}

In your case, the type is not copy constructible (it's an std::unique_ptr!!) and therefore the first branch should be suppressed.
However, the copy constructor of an std::vector always exists and is conditionally enabled on use if the value type is also copy constructible.
Again. It always exists. It's conditionally suppressed on use. This means that the following is true, no matter what:

std::is_copy_constructible_v<std::vector<std::unique_ptr<T>>>

Even though std::vector<std::unique_ptr<T>> isn't copyable because std::unique_ptr isn't copyable. That's funny. 😅
It goes without saying that the compiler enters the first branch because of this and thus this call pops up in your code:

return emplace_element(entt, force_back, *static_cast<const value_type *>(value));

However, the vector isn't really copyable and here is where you get the compile-time error.

I do love C++ sometimes.

Can you solve it? Sure thing. Just wrap the vector in a non-copyable type (make it explicit!) to help the compiler.
Can you use an std::vector of std::unique_ptrs directly as a component? Not really. Either this or the opaque emplace. Since there isn't a way to get around the lack of the second, we opted for it.

[jhasse]

Thanks for looking into it and the explanation! I will go with the non-copyable type :)

This explains why std::vector always has the copy constructor: https://quuxplusone.github.io/blog/2020/02/05/vector-is-copyable-except-when-its-not/

[yumeyao]

bang! Thanks google I can still find this post from the keyword "c++ vector always copyable". This is very unintuitive and seems no way to fix it besides hacking into the compiler - even so, it involves code-generation stage thus extremely hard to do so. I even wonder if the forthcoming static reflection could help this because of the same reason.