Discussion :

[DakM]

Bonjour,

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

(nb: UpdateServerSession & AuthClientSession = arguments template)

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
 
        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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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.

/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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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

[Trademark]

Ce que je ferais c'est une structure annexe UpdateServerSessionDeleter que tu spécialises en fonction du type, de cette manière :

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 <class T>
struct UpdateServerSessionDeleter
{
  template <class... Args>
  static void reset(net::null_class d, Args... args)
  {}
};
 
template <>
struct UpdateServerSessionDeleter<UpdateServerSession>
{
  template <class... Args>
  static void reset(shared_ptr<UpdateServerSession> &d, Args... args)
  {
    d = make_shared_ptr<UpdateServerSession>(args...);
  }
}

Note que j'ai utilisé des shared_ptr, peut-être que unique_ptr conviendrait mieux. D'une manière général, si il y a plus de points de variation, fait une classe de police pour tes types.