Bonjour à vous

Je viens de penser à mettre en forme une espèce de machine état.
Pour cela j'utilise une classe template de base : une sorte de cellule de base pour la machine état :
Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
template <typename T>
class CellStateMachine
{
    public:
        CellStateMachine(T param, boost::shared_ptr<std::list<boost::function<void (T)> > > listFunctions = boost::shared_ptr<std::list<boost::function<void (T)> > >());
        CellStateMachine(const CellStateMachine<T> &cpy);
 
        void setParam(T param);
        T getParam() const;
 
        void setListFunctionToCall(boost::shared_ptr<std::list<boost::function<void (T)> > > listFunctions);
        const boost::shared_ptr<std::list<boost::function<void (T)> > > getListFunctionsToCall() const;
 
    private:
        typedef boost::function<void (T)> func;
        T m_param;
        boost::shared_ptr<std::list<boost::function<void (T)> > > m_functionsToCall;
};
Ensuite je regroupe ces cellules dans un tuple :
Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
 
template <unsigned int Count, typename ... Args>
class SuperCellStateMachine
{};
 
template <typename Head>
class SuperCellStateMachine<0,Head>
{
    public:
        SuperCellStateMachine(boost::shared_ptr<CellStateMachine<Head> > &cell) :
            m_cell(cell)
        {}
 
        boost::shared_ptr<CellStateMachine<Head> > m_cell;
};
 
template <unsigned int Count, typename Head, typename ... Args>
class SuperCellStateMachine<Count,Head,Args...>
{
    public:
        SuperCellStateMachine(boost::shared_ptr<SuperCellStateMachine<Count-1,Args...> > &superCell, boost::shared_ptr<CellStateMachine<Head> > &cell) :
            m_superCell(superCell),
            m_cell(cell)
        {}
 
        boost::shared_ptr<SuperCellStateMachine<Count-1,Args...> > m_superCell;
        boost::shared_ptr<CellStateMachine<Head> > m_cell;
};
Le problème est que je dois arriver à obtenir facilement chaque élément du tuple sans perte de temps excessive. En plus, vu la manière dont j'ai codé ça, je me suis rendu compte que ce n'était pas très pratique vu qu'il faut à chaque fois créer un pointeur sur une cellule, puis un pointeur sur une supercellule en utilisant le pointeur précédent, et continuer ainsi, en escalier, avec toujours plus de pointeurs et de template dans les supercellules créées.

J'ai donc 2 questions : comment avec une structure similaire parvenir à accéder à chaque élément du tuple de manière rapide à la manière d'un get<N> de boost::tuple et comment optimiser ce que j'ai fait ou le remodeler de manière à disposer de quelque chose de simple à initialiser et à utiliser ?