Jak używać boost :: mpl do komponowania zasad?

Question

użyłem czegoś takiego do komponowania polityk dla mojej aplikacji:

Klasy polityki wyglądać następująco:

struct Policy { 
    static void init(); 
    static void cleanup(); 
    //... 
}; 

template <class CarT, class CdrT> 
struct Cons { 
    static void init() { 
    CarT::init(); 
    CdrT::init(); 
    } 
    static void cleanup() { 
    CdrT::cleanup(); 
    CarT::cleanup(); 
    } 
    //... 
}; 

Aby skomponować polityk:

typedef Cons<Policy1, Cons<Policy2, Cons<Policy3, Policy4> > > MyPolicy; 

Aby korzystać MyPolicy:

init_with<MyPolicy>(...); 
//... 
cleanup_with<MyPolicy>(...); 

gdzie mieliby zadzwonić:

MyPolicy::init_options(); // calls Policy1 to 4's init in order 

i

MyPolicy::cleanup(); // calls Policy1 to 4's cleanup in reverse order 

Zasadniczo Wady konstruuje listę wpisz tutaj. To całkiem proste. Jednak linia przeciwna jest trochę brzydka. To będzie idealny mieć politykę sumator, który może to zrobić:

typedef CombinePolicy<Policy1, Policy2, Policy3, Policy4> MyPolicy; 

Ponieważ możemy mieć dowolną liczbę polityk, CombinePolicy musiałby o zmiennej liczbie argumentów pomocy szablonu w C++ 0x, który jest dostępny tylko eksperymentalnie cięcia kompilatory krawędzi. Wydaje się jednak, że boost: biblioteka mpl rozwiązała/rozwiązała problem za pomocą sztuczek preprocessingu grupowego. Chyba mogę używać coś takiego:

typedef mpl::list<Policy, Policy2, Policy3, Policy4> Policies; 

a następnie wywołuje:

init_with<Policies>(...); 

które następnie użyć:

typedef iter_fold<Policies, begin<Policies>::type, 
        some_magic_lambda_expression>::type MyPolicy; 

Oczywiście, mam mały problem ze zorientowaniem się some_magic_lambda_expression tutaj. Jestem pewien, że dla ekspertów od mpl jest to dość trywialne.

Z góry dziękuję.

Answer 1

Myślę, że twój problem jest raczej wywołaniem czasu wykonywania niż metapunkcje, ponieważ chcesz wywoływać funkcje init na rzeczywistych obiektach środowiska wykonawczego.

można spróbować algorytmy wykonawcze MPL, jak:

for_each<Policies>(InitPolicy()); 

z

struct InitPolicy() { 
    template<class Policy> 
    void operator() (Policy& p) { p.init_options(); } 
}; 

Answer 2

myślę szukasz czegoś podobnego:

typedef 
    iter_fold< 
    Policies, 
    begin<Policies>::type, 
    Cons<_1,_2> 
    >::type 
    MyType; 

też może zaglądać do inherit_linearly<>, jeśli wbudujesz coś w rodzaju CRTP, aby wywołać funkcje bazy są podłączone na stałe podczas kompilacji.

Answer 3

Ponieważ nikt nie odpowiedział na pytanie w zadowalający sposób, spędziłem czas na wkopaniu się w źródło boost :: mpl. Człowieku, nie jest ładny z warstwami makr i setkami linii klas specjalizacyjnych.Teraz mam większe uznanie dla autorów bibliotek boost, aby uczynić programowanie meta łatwiejszym i bardziej przenośnym dla nas. Mam nadzieję, że C++ 0x również ułatwi pisarzom bibliotekę.

W każdym razie rozwiązanie okazuje się proste i eleganckie.

Pierwszy iter_fold nie jest tym, czego chcę, ponieważ nie mogłem wymyślić, jak określić iterator, który można odwołać do typu zerowego. Więc bawił się wokół z krotnie i znaleźć następujące:

typedef fold<Policies, Null, Cons<_1, _2> >::type MyPolicy; 

Aby to działało, muszę dostarczyć Null rodzaj i specjalizacji dla Wady:

struct Null { }; 

template<class PolicyT> 
struct Cons<Null, PolicyT> { 
    static void init() { PolicyT::init(); } 
    static void cleanup() { PolicyT::cleanup(); } 
};