Execution d'une partie de code en fonction d'argument templates

Bonjour,

Ca rouille quand on ne C++ pas pendant un bout de temps ^^
Une partie de mon code...

(nb: UpdateServerSession & AuthClientSession = arguments template)

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
 
        template<
                  typename UpdateClientSession,
                  typename UpdateServerSession,
                  typename AuthClientSession,
                  typename AuthServerSession>
// fun
// code...
                                catch(const handlers::change_handler<UpdateServerSession>& ch)
                                {
                                    if(!std::is_same<UpdateServerSession, net::null_class>::value)
                                    {
                                        delete client_iterator->second;
                                        client_iterator->second = new UpdateServerSession(socket);
                                    }
                                }
                                catch(const handlers::change_handler<AuthClientSession>& ch)
                                {
                                    if(!std::is_same<AuthClientSession, net::null_class>::value)
                                    {
                                        delete client_iterator->second;
                                        client_iterator->second = new AuthClientSession(socket, ch.some_id);
                                    }

Le soucis, c'est que le compilo se fiche royalement de mon if(! std::is_same ) et tente de compiler, alors forcément...
En gros, je passe une classe vide dans mes arguments templates:

Code:

mysocket.launch<net::null_class, net::null_class, sessions::client<Protocol>, Ssp>(myserver);

Et du coup, bah j'ai une tonne de problèmes de construction avec null_class.

Citation:

/media/data/dev/projects/baws/baws/net/networker_server.h|82|error: no matching function for call to ‘net::null_class::null_class(net::socket_impl<net::protocols::TCP>&)’|

De plus, les arguments templates peuvent tous etre = null_class.

J'ai tenté d'envelopper le probleme autour d'une structure & une lambda:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
template<bool Do, typename Fn>
    struct execute
    {
        typename std::enable_if<Do, void>::type
        call(Fn f) { f(); }
    };
 
// ...
 
                                        auto f = [&client_iterator, &socket](void) -> void
                                        {
                                            delete client_iterator->second;
                                            client_iterator->second = new UpdateClientSession(socket);
                                        };
                                    lambda::execute<!std::is_same<UpdateClientSession, net::null_class>::value, decltype(f)>::call(f);

Mais le problème persiste.
J'aimerais avoir une solution qui passe par un template, et que le compilo ne tente pas d'executer le 'new' pour eviter des entourloupes dans mon code (car là, j'aurais encore plus de boulot !)
Bon il est tard, j'espere m'exprimer bien !
Merci d'avance

nico