Re: Design problem using Multiple Dispatch or Redispatch (long)

["Nick Roberts" <nickroberts@callnetuk.com>]

First, you define an access-to-procedure type as follows:

    type Command_Executor is procedure (Command: Root_Command_Type'Class;
                                            Processor:
Root_Processor_Type'Class);

Now - and this is the key bit - you define two types which classify your
commands and processors:

    type Command_Category is (...);
    type Processor_Category is (...);

And functions that will categorise a command or processor:

    function Category (Command: in Root_Command_Type) return
Command_Category;
    function Category (Processor: in Root_Processor_Type) return
Processor_Category;

Now you declare an array which relates categories to executors:

    Executor: constant array (Command_Category,
                                        Processor_Category) of
Command_Executor :=
        (Elbow_Bending =>
            Teenagers => Execute_Bend_Elbow_On_Teenager'Access,
            Twentysomethings =>
Execute_Bend_Elbow_On_Twentysomething'Access,
            ...
            Ancient_Crinklies => null);
         ...);

Null access values are used to indicate which kinds of command cannot be
executed by which kinds of processor. Note how commands and processors can
be added without necessarily having to change this lookup table (provided
they fit into existing categories). I've made the array constant, so the
addition of a new category could prompt substantial recompilation: if this
might be a problem, you might want to consider using a variable table, with
some kind of dynamic 'registration' method for populating it.

--
Nick Roberts
http://www.adapower.com/lab/adaos