Combining dynamic and static policies

[I've also posted this on boost-user some days ago]

Hi,

I have the following task: There is an algorithm where you can set
different behaviors for creating a BFS tree. Currently this is done by
setting a policy object (dynamic), a function of which is called to
perform the search.

I'd like to use static policies here (as is done in generic Boost
algorithms), but still keep the possibility of setting the behavior
manually. The reason for this is: You can set the behavior using a
command line parameter, and it would be impractical to instantiate all
templates and then use a huge switch (think of combinations of several
policies) to choose the appropriate instantiation. Here a wrapper
(dynamic polymorphism) would be needed anyway, or any code using the
algorithm would need to be duplicated as well.

So my idea is as follows: There is a template parameter for a policy
class. Static policy exist for each possible behavior, as well for a
dynamic behavior. The "dynamic" policy class has virtual member
functions and there exists an inheriting dynamic class for each behavior.[1]

The algorithm then has a named param for the policy class. Default value
if to default-construct an object of the policy class. (If useful, the
template might have a default value for the policy template parameter as
well, so the user needn't do anything).

Has someone already taken this or a similiar approach? If so, could you
point me to a reference? What do you think of the approach?

Greeting,

Jens

[1] Hmmm ... Could this inheriting class be used as template parameter
without overhead? Other solution would be:

class dyn_behavior{

public:
   virtual void perform_search(something ...) = 0;
}

class specific_dyn_behavior<class T> : dyn_behavior {
   T behavior;

public:
   void perform_search(something ...){
     behavior.perform_search(something ...);
   }
}

--
      [ See http://www.gotw.ca/resources/clcm.htm for info about ]
      [ comp.lang.c++.moderated. First time posters: Do this! ]