comparaison de deux types templates ou recuperation dynamique d'un type de variable

Bonjour,

Je pense que le sujet n'est pas top, mais je vois pas comment l'exprimer ...
J'ai une classe templatée qui herite d'une autre, pour avoir un type commun, pour pouvoir stocker la premier dans une map .

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 Cast, typename IdType>
struct shared_pointer
{
	typedef std::shared_ptr<Cast> ptr;
	typedef IdType id_t;
};
 
    class item_impl: public shared_pointer<item_impl, fs::size_t> {};
    typedef std::unordered_multimap<item_impl::id_t, item_impl::ptr> loaded_items_t;
    template<typename loadType>
    class loaded_item: public item_impl
    {
    public:
        typedef loadType type;
        loaded_item(fs::node::ptr node, const std::vector<char>& bin);
        virtual ~loaded_item() {}
        loadType& operator()() { return m_data; }
        fs::node::ptr& node() { return m_node; }
    protected:
        fs::node::ptr m_node;
        loadType m_data;
    };

Ensuite, j'ai une autre classe, qui va se charger de la creation :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
    class node_loader: public basic_exceptions, public shared_pointer<node_loader, std::string>
    {
    public:
        node_loader(fs::pack<std::ifstream>::ptr pl) : m_reader(pl) {}
        virtual ~node_loader() { m_loaded.clear(); }
        template<typename loadType>
        typename loaded_item<loadType>::ptr operator()(item_impl::id_t id)
        {
            auto found(std::find_if(std::begin(m_loaded),
                                    std::end(m_loaded),
                                    [&id](const loaded_items_t::value_type& l)
                                    {
                                        return (l.first == id && std::is_same<loadType, l.second::type>::value);
                                    }));
            if(found == std::end(m_loaded)) throw not_found();
            else return found.second;
        }
    private:
        fs::pack<std::ifstream>::ptr m_reader;
        loaded_items_t m_loaded;
    };

La ligne en rouge, en gros, je voudrais comparer le type donné en argument template avec le type du typedef de l'element iteré (cf: typedef loadType type;)

Evidemment, le compilo me sors:

Citation:

error: expected a type, got ‘l.second’|

Une autre facon à laquelle j'avais penser, est de sortir ces templates, et d'avoir un truc qui permettrais de recuperer le type (facon decltype) a partir d'une map... Voici le code que vous pouvez bidouiller !

Code:

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
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
 
#include <map>
#include <iostream>
#include <utility>
#include <typeinfo>
#include <string>
class A {};
class B {};
struct type_forward
            {
                /// NOTE: Add more type-forwarding here
                struct type_impl
                {
                    typedef int key_type;
                };
                struct A_forward: public type_impl
                {
                    typedef A type;
                };
                struct B_forward: public type_impl
                {
                    typedef B type;
                };
                struct string_forward: public type_impl
                {
                    typedef std::string type;
                };
                static std::map<type_impl::key_type, type_impl> type_forwardings;
            };
std::map<type_forward::type_impl::key_type, type_forward::type_impl> type_forward::type_forwardings =
    std::map<type_forward::type_impl::key_type, type_forward::type_impl>();
int main()
{
    type_forward::type_forwardings.insert({1, type_forward::A_forward()});
    type_forward::type_forwardings.insert({2, type_forward::B_forward()});
    type_forward::type_forwardings.insert({3, type_forward::string_forward()});
    auto X(type_forward::type_forwardings.at(1));
    auto XX(type_forward::type_forwardings.at(2));
    auto XXX(type_forward::type_forwardings.at(3));
 
    decltype(X)::type Z; /// Z doit être de type A !
    decltype(XX)::type ZZ; /// ZZ doit être de type B !
    decltype(XXX)::type ZZZ; /// ZZZ doit être de type std::string !
}

germinolegrand me parlais de double dispatch, mais je n'y comprend rien.
ideone > http://ideone.com/VCwgt8

merci d'avance