Question about implementation of registry::valid

[chw0239]

I'm wondering why entt::registry::is_valid is implemented in this way:

[[nodiscard]] bool valid(const entity_type entt) const {
    return static_cast<size_type>(entities.find(entt).index()) < entities.free_list();
}

To my understanding, the information of entities is stored in registry.entities or registry.storage<entt::entity>(), and an entity is valid as long as it is stored in registry.storage<entt::entity>(), so registry.storage<entt::entity>().contains(my_entity) should be sufficient to test the validity of an entity. What's the purpose of the additional checks?
I compared the value of registry.valid(my_entity) and registry.storage<entt::entity>().contains(my_entity) in my testcases, and it seems they are always same. So are both patterns correct? Or there are some edge cases?

[skypjack]

Good question. They are the same, but for a very specific case.
When you delete an identifier, the entity remains the same while the version is increased. The new identifier is kept in the storage for reuse.
In theory, you can then construct the same identifier with the entity traits and query the storage for validity. Since the identifier is there, but is reserved for recycling, it's invalid from the point of view of the user. That is, it wasn't returned yet nor made available.
Will anyone ever do this type of query? I don't think so. However, the check you see prevents errors. You never know? 🙂

[chw0239]

I see, so the special case is like following:

entt::registry reg{};
auto E1 = reg.create();
auto v1 = entt::entt_traits<entt::entity>::to_version(E1);
auto e1 = entt::entt_traits<entt::entity>::to_entity(E1);
reg.destroy(E1);
auto E2 = entt::entt_traits<entt::entity>::construct(e1, v1 + 1);
std::cout << int(E1) << std::endl;
std::cout << int(E2) << std::endl;
std::cout << "valid: " << reg.valid(E2) << std::endl;  // false
std::cout << "contains: " << reg.storage<entt::entity>().contains(E2) << std::endl;  // true!!!

That's really interesting.
Inspired by this, I found another shocking fact:

entt::registry reg{};
auto E1 = reg.create();
reg.emplace<SomeComponent1>(E1);
reg.destroy(E1);
for (auto ett : reg.storage<entt::entity>().each())
{
	std::cout << "aaa" << std::endl;  // not called
}
for (auto ett : reg.storage<entt::entity>())
{
	std::cout << "bbb" << std::endl;  // called
}
for (auto ett : reg.storage<SomeComponent1>().each())
{
	std::cout << "xxx" << std::endl;  // not called
}
for (auto ett : reg.storage<SomeComponent1>())
{
	std::cout << "yyy" << std::endl;  // not called
}
std::cout << "storage<entt::entity> " << reg.storage<entt::entity>().size() << std::endl;  // 1
std::cout << "storage<SomeComponent1> " << reg.storage<SomeComponent1>().size() << std::endl; // 0

I used to think that storage and registry are highly equivalent, now I see that is not exactly so. Thank you!

[skypjack]

I see, so the special case is like following:

You, you got it.

I found another shocking fact: [...] I used to think that storage and registry are highly equivalent

What's shocking with it? What do you mean with they are equivalent? Not sure I get your reasoning, sorry.

[chw0239]

Sorry for late, I mean that the storage of entity and the storage of component behave differently when iterated, due to their deletion policy. It is beyond my expectation, because in some case I might visit some destroyed entities.
Here is a testcase:

struct Comp
{
	int x = 1;
};

struct CompInPlaceDelete
{
	constexpr static bool in_place_delete = 1;
	int x = 1;
};

int main()
{
	entt::registry reg{};
	auto ett = reg.create();
	reg.emplace<Comp>(ett);
	reg.emplace<CompInPlaceDelete>(ett);
	reg.destroy(ett);

	auto testfunc = [](auto& storage)
		{
			using storage_type = std::remove_cvref_t<decltype(storage)>;
			using storage_element_type = storage_type::element_type;
			const char* deletion_policy = storage.policy() == entt::deletion_policy::in_place ? "in_place" : (storage.policy() == entt::deletion_policy::swap_and_pop ? "swap_and_pop" : "swap_only");
			std::cout << "Testing storage for " << entt::type_name<storage_element_type>::value() << std::endl;
			std::cout << "deletion policy is " << deletion_policy << std::endl;

			for (auto ett : storage.each())
			{
				std::cout << "  storage.each() visits destroyed entity" << std::endl;
			}
			for (auto ett : storage)
			{
				std::cout << "  storage.begin()/end() visits destroyed entity" << std::endl;
			}

			std::cout << "  storage size = " << storage.size() << std::endl;
			std::cout << std::endl;
		};

	testfunc(reg.storage<entt::entity>());
	testfunc(reg.storage<Comp>());
	testfunc(reg.storage<CompInPlaceDelete>());

	return 0;
}

Here, an entity is create with some components then destroyed, and then the content of the storages are printed.
The code produced following output:

Testing storage for enum entt::entity
deletion policy is swap_only
    storage.begin()/end() visits destroyed entity
    storage size = 1

Testing storage for struct Comp
deletion policy is swap_and_pop
    storage size = 0

Testing storage for struct CompInPlaceDelete
deletion policy is in_place
    storage.each() visits destroyed entity
    storage.begin()/end() visits destroyed entity
    storage size = 1

There are two points shocking me:

1. When deletion policy is in_place or swap_only, the iteration become unsafe
2. Iterating using ranged-for on storage or storage.each() might produce different result, depending on deletion policy.

So, I want to know whether it is encouraged to operate directly on storage rather than registry? If so, these subtle differences might cause problems if the user is not informed about it.
In my projects, I often extract some storage from registry and deep copy them, and in another thread I will iterate over those cloned storages. Is this usage allowed?

[chw0239]

After reading the docs, I realize that a view/runtime_view is needed when iterating a storage. I updated my testcase:

struct Comp
{
	int x = 1;
};

struct CompInPlaceDelete
{
	constexpr static bool in_place_delete = 1;
	int x = 1;
};

int main()
{
	entt::registry reg{};
	auto ett = reg.create();
	reg.emplace<Comp>(ett);
	reg.emplace<CompInPlaceDelete>(ett);
	reg.destroy(ett);

	auto testfunc = [](auto& storage)
		{
			using storage_type = std::remove_cvref_t<decltype(storage)>;
			using storage_element_type = storage_type::element_type;
			const char* deletion_policy = storage.policy() == entt::deletion_policy::in_place ? "in_place" : (storage.policy() == entt::deletion_policy::swap_and_pop ? "swap_and_pop" : "swap_only");
			std::cout << "Testing storage for " << entt::type_name<storage_element_type>::value() << std::endl;
			std::cout << "deletion policy is " << deletion_policy << std::endl;

			for (auto ett : storage.each())
			{
				std::cout << "    storage.each() visits destroyed entity" << std::endl;
			}
			for (auto ett : storage)
			{
				std::cout << "    storage.begin()/end() visits destroyed entity" << std::endl;
			}
			{
				entt::basic_view temp_view{ storage };
				for (auto ett : temp_view.each())
				{
					std::cout << "    view.each visits destroyed entity" << std::endl;
				}
				for (auto ett : temp_view)
				{
					std::cout << "    view visits destroyed entity" << std::endl;
				}
			}
			{
				entt::runtime_view runtime_v{};
				runtime_v.iterate(storage);
				for (auto ett : runtime_v)
				{
					std::cout << "    runtime_view visits destroyed entity" << std::endl;
				}
				runtime_v.each([](auto ett)
					{
						std::cout << "    runtime_view.each visits destroyed entity" << std::endl;
					}
				);
			}

			std::cout << "    storage size = " << storage.size() << std::endl;
			std::cout << std::endl;
		};

	testfunc(reg.storage<entt::entity>());
	testfunc(reg.storage<Comp>());
	testfunc(reg.storage<CompInPlaceDelete>());

	return 0;
}

The result is following:

Testing storage for enum entt::entity
deletion policy is swap_only
    storage.begin()/end() visits destroyed entity
    runtime_view visits destroyed entity
    runtime_view.each visits destroyed entity
    storage size = 1

Testing storage for struct Comp
deletion policy is swap_and_pop
    storage size = 0

Testing storage for struct CompInPlaceDelete
deletion policy is in_place
    storage.each() visits destroyed entity
    storage.begin()/end() visits destroyed entity
    storage size = 1

It seems that basic_view/runtime_view can correctly filter out destroyed entities in storages of components, but runtime_view still visited destroyed entities in storage of entity.
So when I need to iterate a storage outside a registry directly, I must wrap it with a basic_view, is that correct?