I have been studying several entity component systems (Anax and EntityX) to get an idea of how they work.
For Entity ids, both use 2 numbers. The first number is basically a position in an array, and a second number is the "version" for the entity at that index. If a handle to an entity at a given index has a "version" older than the the version the container currently has, the handle is considered invalid. This would occur when an entity is deleted from the world and its index becomes free for a new entity.
This approach seems to suggest the maximum number of times an index can be reused is limited to whatever the max number a
uint32_t (or whatever the system chooses to use) can hold.
In practice, I suppose this wouldn't occur often, but it doesn't seem impossible. If I made a simulation that endlessly spawned entities, moved them around on the screen a bit, and deleted them once they were off screen, then the program would eventually crash, or exhibit strange behavior, once the version number for an index reached the max for an int.
Here are some of the specific lines I've been looking at for each:
Is this a shortcoming of reusing indexes, and needing to invalidate old handles? Is there any real practical concern since even a 32bit in has a max value of 4 billion or so? Could these systems be broken by a soak test with a long, ongoing stream of short-lived entities?