On Friday, 12 March 2021 at 19:24:17 UTC, David Zhang wrote:
On Friday, 12 March 2021 at 18:50:26 UTC, tsbockman wrote:
<snip>
The idea is to implement a service locator s.t. code like this
is possible:
...
I don't really need to copy or move the class instances here,
just be able to read, assign, and replace references to them in
the same place that I read, assign, and replace void[]'s of
structs.
Why do you think you need a `void[]` slice? I think `void*`
pointers are sufficient. This handles all normal data types, as
long as they are allocated on the GC heap:
////////////////////////////////
/* NOTE: It might be wiser to make this a `final class`
instead of a `struct` to get reference semantics: */
struct Registry {
private void*[TypeInfo] map;
/// Return true if the registry was updated, false if not.
bool put(bool overwrite = true, Indirect)(Indirect i) @trusted
if(is(Indirect : T*, T) // Support structs, static arrays,
etc.
|| is(Indirect == interface) || is(Indirect == class))
{
auto key = typeid(Indirect), value = cast(void*) i;
bool updated;
if(value is null)
updated = map.remove(key);
else {
static if(overwrite) {
updated = true;
map[key] = value;
} else
updated = (map.require(key, value) is value);
}
return updated;
}
alias put(Indirect) = put!(true, Indirect);
bool remove(Indirect)() @trusted
if(is(Indirect : T*, T) // Support structs, static arrays,
etc.
|| is(Indirect == interface) || is(Indirect == class))
{
return map.remove(typeid(Indirect));
}
/** Returns a reference (for interfaces and classes) or
a pointer (for everything else) if the type has been
registered,
and null otherwise. **/
Indirect get(Indirect)() @trusted
if(is(Indirect : T*, T) // Support structs, static
arrays, etc.
|| is(Indirect == interface) || is(Indirect == class))
{
return cast(Indirect) map.get(typeid(Indirect), null);
}
}
@safe unittest {
static interface I {
char c() const pure @safe nothrow @nogc;
}
static class C : I {
private char _c;
this(char c) inout pure @safe nothrow @nogc {
this._c = c; }
override char c() const pure @safe nothrow @nogc {
return _c; }
}
static struct S {
char c = 'S';
this(char c) inout pure @safe nothrow @nogc {
this.c = c; }
}
Registry registry;
assert( registry.put!false(new C('1')));
assert( registry.put!I(new C('2')));
assert( registry.put(new S('$')));
assert(!registry.put!false(new C('3'))); // Optionally
protect existing entries.
assert(registry.get!(I).c == '2');
assert(registry.get!(C).c == '1');
assert(registry.remove!I);
assert(registry.get!I is null);
assert(registry.get!C !is null);
assert(registry.get!(S*).c == '$');
assert(registry.get!(int*) is null);
}
////////////////////////////////
NOTE: If you only need one Registry instance in per thread, then
you probably don't need the associative array at all; instead
just use a template like this:
////////////////////////////////
template registered(Indirect)
if(is(Indirect : T*, T) // Support structs, static arrays,
etc.
|| is(Indirect == interface) || is(Indirect == class))
{
/* This uses thread local storage (TLS). Sharing across the
entire
process is possible too, but would require synchronization of
the
registered objects, not just this reference/pointer: */
private Indirect indirect = null;
/// Return true if the registry was updated, false if not.
bool put(bool overwrite = true)(Indirect i) @safe
{
bool updated = (indirect !is i);
static if(overwrite) {
indirect = i;
} else {
updated &= (indirect is null);
if(updated)
indirect = i;
}
return updated;
}
bool remove() @safe {
bool updated = (indirect !is null);
indirect = null;
return updated;
}
/** Returns a reference (for interfaces and classes) or
a pointer (for everything else) if the type has been
registered,
and null otherwise. **/
Indirect get() @safe {
return indirect; }
}
@safe unittest {
static interface I {
char c() const pure @safe nothrow @nogc;
}
static class C : I {
private char _c;
this(char c) inout pure @safe nothrow @nogc {
this._c = c; }
override char c() const pure @safe nothrow @nogc {
return _c; }
}
static struct S {
char c = 'S';
this(char c) inout pure @safe nothrow @nogc {
this.c = c; }
}
assert( registered!(C).put!false(new C('1')));
assert( registered!(I).put(new C('2')));
assert( registered!(S*).put(new S('$')));
assert(!registered!(C).put!false(new C('3'))); // Optionally
protect existing entries.
assert(registered!(I).get.c == '2');
assert(registered!(C).get.c == '1');
assert(registered!(I).remove());
assert(registered!(I).get is null);
assert(registered!(C).get !is null);
assert(registered!(S*).get.c == '$');
assert(registered!(int*).get is null);
}
////////////////////////////////
Aye, I'm using hashes. The idea is to support either D
interfaces or structs with arbitrary content.
You can use TypeInfo references as the keys for the struct types,
too. It's better than hashes because the TypeInfo is already
being generated anyway, and is guaranteed to be unique, unlike
your hashes which could theoretically collide.
`I` is *not* the type of an interface instance, it is the type
of a reference to an instance of the interface.
So `I i` is a reference to the instance, which itself holds a
reference to the implementation, like a reference to a delegate
(pointer to (ctx, fn))?
No. What you are calling "the implementation" is the same thing
as "the instance". `I i` is a reference into the interior of the
implementing class instance, offset such that it points at the
virtual function table pointer for that interface. The lowering
is something like this:
////////////////////////////////
interface I { ... }
class C : I { ... }
struct C_Instance {
void* __vtblForC;
// ... other junk
void* __vtblForI;
// ... explicit and inherited class fields, if any.
}
C c = new C; // Works like `C_Instance* c = new C_Instance;`
I i = c; // Works like `void** i =
(C_Instance.__vtblForI.offsetof + cast(void*) c);`
////////////////////////////////
You can prove this to yourself by inspecting the raw numerical
addresses. You will find that the address used by the interface
reference points to a location *inside* the instance of C:
////////////////////////////////
void main() {
import std.stdio : writeln;
static interface I { char c() @safe; }
static class C : I { override char c() @safe { return 'C'; } }
C c = new C;
const cStart = cast(size_t) cast(void*) c;
const cEnd = cStart + __traits(classInstanceSize, C);
I i = c;
const iStart = cast(size_t) cast(void*) i;
writeln(cStart <= iStart && iStart < cEnd);
}
////////////////////////////////
Thus cast(void*) produces something like *(ctx, fn).
No. See above.
