Storing interfaces as void[]

[tsbockman]

On Friday, 12 March 2021 at 17:37:43 UTC, David  Zhang wrote:
> I want to store interfaces as untyped void[], then cast them 
> back to the interface at a later time.

Assuming these interfaces are actual D `interface`s, declared 
with the keyword and using the default `extern(D)` linkage, 
you're way over-complicating things. All `extern(D)` `class`es 
are sub-types of `object.Object`, and have type information 
accessible through the implicit virtual function table pointer 
`__vptr` that can be used to perform safe dynamic casts:

////////////////////////////////////////////
/* Fully qualified names can be *very* long because of templates, 
so it can be wasteful to store and compare them at runtime. Let's 
use `TypeInfo` instead: */
Object[TypeInfo] map;

void register(I)(I i)
     if(is(I == interface)) // This wouldn't work right with value 
types like structs.
{
     /* The garbage collector will keep the instance referenced by 
`i` alive for us
     as long as necessary. So, there is no need to copy the 
instance unless we want
     to be able to mutate it elsewhere without affecting the 
instance refrenced by
     `map`. */

     /* `typeid(i)` will compile, but probably doesn't do what you 
want: you need to
     retrieve the value using the same key you put it in with, and 
below that has
     to be `typeid(I)`: */
     map[typeid(I)] = cast(Object) i;
}

I get(I)()
     if(is(I == interface)) // This wouldn't work right with value 
types like structs.
{
     /* This will return `null` if the value isn't really a 
reference to an instance
     of a subtype of `I`, or if the key isn't in the map yet. If 
you don't care
     about the latter case, it can be shortened to just `cast(I) 
map[I.stringof]`. */
     auto valuePtr = (typeid(I) in map);
     return (valuePtr is null)? null : cast(I) *valuePtr;
}
////////////////////////////////////////////

Many variations on this are possible, depending on exactly what 
you're really trying to accomplish. This is my best guess as to 
what you're after, though, without seeing the context for the 
code you posted.

> However, it appears to produce garbage values on get().
>
> Is this even possible, and if so, what is happening here? The 
> alternative would be a struct { CheckedPtr self; api_fns.... }
>
> e.g.
>
> void register(I)(I i) {
>   auto mem = new void[](I.sizeof);
>   memcpy(mem.ptr, cast(void*) i, I.sizeof);
>
>   // CheckedPtr includes a hash of fullyQualifiedName
>   map[i.get_name()] = CheckedPtr!I(mem.ptr);
> }
>
> I get(I)() {
>   // basically cast(I) p
>   return map[I.get_name()].as!I();
> }

Your code confuses two levels of indirection (because D makes 
this super confusing); that is why it doesn't do what you want. 
`cast(void*) i` is an untyped pointer to some class instance, 
while `I.sizeof` is the size of *the pointer itself*, NOT the 
instance it points to.

`I` is *not* the type of an interface instance, it is the type of 
a reference to an instance of the interface. (A reference is a 
pointer that sometimes automatically dereferences itself.) So, 
I.sizeof is always (void*).sizeof, the size of a pointer.

The types of class and interface instances cannot be named or 
referenced in D, but `__traits(classInstanceSize, C)` will get 
you the size of an instance of class `C`. Getting the size of an 
interface instance isn't really a sensible thing to do, since the 
whole point of interfaces is that you don't need to know about 
the implementing type to work with them. Regardless, copying or 
moving the memory of a class instances directly is generally a 
bad idea, for various reasons.