Re: Map type to class instance at compile-time

[Ali Çehreli via Digitalmars-d-learn]

On 10/26/2016 10:48 AM, pontius wrote:
> Apologies for the long post or stupid questions, I only started to learn
> D today.
Looking at what you've achieved in one day, we really need you! :)

> I have a use case where various types (A, B, C) need to be associated
> with instances of different classes (ManagerA, ManagerB, ManagerC). A
> certain object (globalManager) should redirect operations on those types
> to their respective managers at compile-time. I intend to use it in the
> following way:
>
> class GlobalManager(TypeToManagerMapping) {
>     public void process(T)(T t) {
>         // Must be resolved at compile-time
>         TypeToManagerMapping.getManagerForType(T).process(t);
>     }
> }
>
> // All these types can be completely unrelated, i.e. no base classes
> struct A {}
> alias ManagerA = DefaultManager!(A)
> struct B {}
> alias ManagerB = DefaultManager!(B)
> struct C {}
> alias ManagerC = SomeCustomManager;
>
> // Calls to globalManager should be redirected to these at compile-time
> auto mgrA = new ManagerA();
> auto mgrB = new ManagerB();
> auto mgrC = new ManagerC();
>
> // This is my problem, see below
> alias TypeToManagerMapping = ...;
>
> // Pass the mapping as a template parameter so that it can be resolved
> at compile-time
> auto globalManager = new GlobalManager!(TypeToManagerMapping)();
>
> // The following is the module user's code.
> // The user may not be aware of mgrA, mgrB, etc, only of globalManager
>
> A a = A();
> B b = B();
> C c = C();
>
> // Redirection to managers in the following operations
> // must be resolved at compile-time
>
> // Should turn into mgrA.process(a), etc
> globalManager.process(a);
> globalManager.process(b);
> globalManager.process(c);

void report(M, T)() {
    import std.stdio : writefln;
    writefln("%s is managing an object of %s", M.stringof, T.stringof);
}

class DefaultManager(T) {
    void manage(T t) {
        report!(typeof(this), T);
    }
}

class SomeCustomManager {
    void manage(C c) {
        report!(SomeCustomManager, C);
    }
}

struct A {}
alias ManagerA = DefaultManager!(A);
struct B {}
alias ManagerB = DefaultManager!(B);
struct C {}
alias ManagerC = SomeCustomManager;

/*/ You can use this:

alias TypeToManagerMapping = AliasSeq!(A, ManagerA,
                                       B, ManagerB,
                                       C, ManagerC);
 However, if you already have symbolic mapping from T to ManagerT, you 
can use string mixins as well
*/
template ManagerRegistrationFor(T) {
    // Just a couple of convenience functions
    string managerType() { return "Manager" ~ T.stringof; }
    string managerName() { return "mng" ~ T.stringof; }

    // This is the manager object
    mixin(managerType() ~ ' ' ~ managerName() ~ ';');

    // This is the initialization of it
    static this() {
        mixin(managerName() ~ `= new ` ~ managerType() ~ ';');
    }

    void manage(T obj) {
        // Dispatches to the manager
        mixin(managerName() ~ ".manage(obj);");
    }
}

struct GlobalManager {
    void process(T)(T t) {
        manage(t);
    }
}

GlobalManager globalManager;

mixin ManagerRegistrationFor!A;
mixin ManagerRegistrationFor!B;
mixin ManagerRegistrationFor!C;

/* The above could be specified with an AliasSeq (uncompiled):

alias ManagedTypes = AliasSeq!(A, B, C);

This loop can be inside a template like RegisterManagedTypes

foreach (T; ManagedTypes) {
    mixin ManagerRegistrationFor!T;
}

And then:

mixin RegisterManagedTypes;

*/

void main() {
    A a = A();
    B b = B();
    C c = C();
    globalManager.process(a);
    globalManager.process(b);
    globalManager.process(c);
}

There are different approaches but I think the solution above achieves 
what you want:

DefaultManager!(A) is managing an object of A
DefaultManager!(B) is managing an object of B
SomeCustomManager is managing an object of C

Ali