registre parametres template

Version imprimable

bonjour ,
pour mon application j'essaye de mettre en place un 'registre' pour stocker des valeurs diverses issues de l'interface pour les transmettre à des parties plus profondes de mon prog.
Apres quelques essais je suis bloqué(int float), il doit y avoir plus simple et plus propre mais je ne sais pas comment faire.
Si quelqu'un a une idée ça seait cool:lol:

.h

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
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
#ifndef PARAMSREGISTER_H
#define PARAMSREGISTER_H
#include <string>
#include <vector>
#include <sstream>
#include <stdlib.h>
 
class ParamsRegister
{
    public:
        ParamsRegister();
        virtual ~ParamsRegister();
 
        void set(std::string name, int value);
        void set(std::string name, float value);
 
        template <class T>
        T get( std::string name);
 
    protected:
    private:
        template<class T>
        std::string toString ( T value);
 
        enum etype { INT_TYPE, FLOAT_TYPE };
 
        struct param
        {
            std::string name;
            std::string value;
            etype type;
        };
 
        std::vector<param> mvParams;
};
 
template <class T>
T ParamsRegister::get( std::string name)
{
    for( auto i : mvParams)
    {
        if (i.name == name)
        {
            switch( i.type)
            {
            case INT_TYPE:
                {
                    int v = atoi( i.value.c_str() );
                    return v;
                    break;
                }
            case FLOAT_TYPE:
                {
                    float v = atof( i.value.c_str() );
                    return v;
                    break;
                }
            }
        }
    }
}
 
template<class T>
std::string ParamsRegister::toString ( T value)
{
    std::stringstream sstr;
    sstr << value;
    return sstr.str();
}
 
#endif // PARAMSREGISTER_H

.cpp

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
 
#include "ParamsRegister.h"
 
ParamsRegister::ParamsRegister()
{
    //ctor
}
 
ParamsRegister::~ParamsRegister()
{
    //dtor
}
 
void ParamsRegister::set(std::string name, int value)
{
    param p;
    p.type = INT_TYPE;
    p.name = name;
    p.value = toString( value);
    mvParams.push_back( p);
}
 
void ParamsRegister::set(std::string name, float value)
{
    param p;
    p.type = FLOAT_TYPE;
    p.name = name;
    p.value = toString( value);
    mvParams.push_back( p);
}

Merci.

Salut,
Code:

1 2 3 4 5 6 7 struct param { union { int int_value; float float_value }; etype type; }; std::map<std::string, param> params;
Ou avec boost :

Code:

std::map<std::string, boost::variant<int, float>> params;

Au moment où tu veux setter tes Int ou Float le type est connu.
Pas vraiment besoin d'union et de tester le type à chaque fois.
Juste 2 maps.
Code:

1 2 std::map< std::string, int > m_IntegerRegisters; std::map< std::string, float > m_FloatRegisters;
Et si tu peux avoir un CRC32 de tes strings, via une hash map ou par toi même cela accélérera rapidement ton code:
Code:

1 2 std::map< unsigned int, int > m_IntegerRegisters; std::map< unsigned int, float > m_FloatRegisters;
Tu peux generaliser avec un:
Code:

1 2 3 4 5 template < typename Type > using Register = std::map< unsigned int, Type >; // Ou alors template < typename Type > using Register = std::map< std::string, Type >;
Ton registre deviens:
Code:

1 2 3 Register< float > m_FloatRegisters; Register< int > m_IntegerRegisters; // ...

25/07/2014, 07h06
Ehonn
Citation:
Envoyé par SKone

Et si tu peux avoir un CRC32 de tes strings, via une hash map ou par toi même cela accélérera rapidement ton code:

Code:

1 2 std::map< unsigned int, int > m_IntegerRegisters; std::map< unsigned int, float > m_FloatRegisters;
Dans ce cas, utiliser directement std::unordered_map<std::string, T>.

bonjour,
merci de vos eclaircissemnets, mais en fait je voudrais juste pouvoir faire ça :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 // debut application Register reg; // initialisation avec des valeurs par defauts reg.set("nb_cube", 10); reg.set("couleur_cube", glm::vec3(1.0,0.0,0.0)); reg.set("dist_cube", 21.53 ); ... // modif par inertface reg.set("nb_cube", 12); ... // boucle de rendu int nb = reg.get("nb_cube"); glm::vec3 color = reg.get("couleur_cube"); float dist = reg.get("dist_cube"); ...
bien_sur le reg sera passé par reference ou quelque-chose comme ça dans le vrai code.
En fait le but ce seait d'avoir un objet qui puisse stocker (set) les valeurs des parametres de types differents et les restituer à la demande (get).
Variadic template??
En tout cas merci.

25/07/2014, 14h01
ternel
Tu n'as que deux cas possibles:
- Les types possibles sont connus, et en nombre fini.
- Ce n'est pas le cas
Dans le premier cas, tu va pouvoir utiliser la surcharge du set, mais pas pour le get (le type de retour n'ai pas un changement suffisant)

En implémentation, tu aura soit une ma<string, variant<int, double, vect3f, ...>> soit plusieurs maps. (<string, int>, <string, double>...)
et les getT/set qui pointent sur le bon type.

Dans le second, tu auras une interface similaire à boost::any (get<T>)
Et l'implémentation sera une map<string, any>.

J'ai un gros penchant pour les plusieurs maps.
26/07/2014, 00h38
fafacpp
Bonsoir,
Les Types sont connus et en nombre fini.
Boost::any pourrait convenir je vais creuser de ce cote, pourquoi lui préférer la solution avec plusieurs map qui semble plus lourde à gérer, si any semble plus generique?
Dans la doc de boost, il y a un truc intéressant :
Citation:
The following type, patterned after the OMG's Property Service, defines name-value pairs for arbitrary value types:

Code:

1 2 3 4 5 6 7 8 9 10 struct property { property(); property(const std::string &, const boost::any &); std::string name; boost::any value; }; typedef std::list<property> properties;
Il faut que je vois comment je peux utiliser ça.
Encore merci pour l'info.

Il y a deux problèmes voisins: l'interface du registre, et son implémentation.

Pour l'implémentation, je reproche à any qu'a chaque appel, il y a un contrôle de validité potentiellement lourd.

Pour l'interface, je trouve raisonnable d'avoir ceci:
Code:

1 2 3 4 5 6 7 8 int main() { Registre registre; registre.load("data.conf"); registre.set("version", "3.1"); cout << registre.getString("nom du capitaine") << " à " <<registre.getInt("age du capitaine") << " ans" << endl; return 0; }

J'ai code vite fait les deux version : boost::any vs multimap.
L'implémentation en multimap est plus concise et l'interface est identique => j'opte pour cette solution.

boost::any :
.h

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
45
46
47
48
49
50
51
52
 
#ifndef PARAMSREGISTER3_H
#define PARAMSREGISTER3_H
/***********************************************************************/
#include <string>
#include <boost/any.hpp>
#include <vector>
#include <glm/glm.hpp>
/***********************************************************************/
class ParamsRegister3
{
public:
    ParamsRegister3();
    virtual ~ParamsRegister3();
 
    void set ( std::string name, int value);
    void set ( std::string name, float value);
    void set ( std::string name, glm::vec2 value);
    void set ( std::string name, glm::vec3 value);
    void set ( std::string name, glm::vec4 value);
    void set ( std::string name, glm::mat3 value);
    void set ( std::string name, glm::mat4 value);
    void set ( std::string name, bool value);
 
    boost::any get (std::string name) const;
 
    int geti (std::string name) const;
    float getf (std::string name) const;
    glm::vec2 getv2 (std::string name) const;
    glm::vec3 getv3 (std::string name) const;
    glm::vec4 getv4 (std::string name) const;
    glm::mat3 getm3 (std::string name) const;
    glm::mat4 getm4 (std::string name) const;
    bool getb (std::string name) const;
 
protected:
private:
    void setOrModify (std::string name, boost::any value );
 
    struct property
    {
        property() {}
        property(const std::string &inName, const boost::any &inValue):name(inName),value(inValue){}
 
        std::string name;
        boost::any value;
    };
 
    std::vector<property> mvProperties;
};
/***********************************************************************/
#endif // PARAMSREGISTER3_H

.cpp

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
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
 
#include "ParamsRegister3.h"
/***********************************************************************/
ParamsRegister3::ParamsRegister3()
{
 
}
/***********************************************************************/
ParamsRegister3::~ParamsRegister3()
{
    //dtor
}
/***********************************************************************/
void ParamsRegister3::set ( std::string name, int value)
{
    setOrModify( name, value);
}
/***********************************************************************/
void ParamsRegister3::set ( std::string name, float value)
{
    setOrModify( name, value);
}
/***********************************************************************/
void ParamsRegister3::set ( std::string name, glm::vec2 value)
{
    setOrModify( name, value);
}
/***********************************************************************/
void ParamsRegister3::set ( std::string name, glm::vec3 value)
{
    setOrModify( name, value);
}
/***********************************************************************/
void ParamsRegister3::set ( std::string name, glm::vec4 value)
{
    setOrModify( name, value);
}
/***********************************************************************/
void ParamsRegister3::set ( std::string name, glm::mat3 value)
{
    setOrModify( name, value);
}
/***********************************************************************/
void ParamsRegister3::set ( std::string name, glm::mat4 value)
{
    setOrModify( name, value);
}
/***********************************************************************/
void ParamsRegister3::set ( std::string name, bool value)
{
    setOrModify( name, value);
}
/***********************************************************************/
boost::any ParamsRegister3::get (std::string name) const
{
    for ( auto i : mvProperties)
    {
        if (i.name == name)
        {
            return i.value;
        }
    }
}
/***********************************************************************/
int ParamsRegister3::geti (std::string name) const
{
    return boost::any_cast<int>(get(name));
}
/***********************************************************************/
float ParamsRegister3::getf (std::string name) const
{
    return boost::any_cast<float>(get(name));
}
/***********************************************************************/
glm::vec2 ParamsRegister3::getv2 (std::string name) const
{
    return boost::any_cast<glm::vec2>(get(name));
}
/***********************************************************************/
glm::vec3 ParamsRegister3::getv3 (std::string name) const
{
    return boost::any_cast<glm::vec3>(get(name));
}
/***********************************************************************/
glm::vec4 ParamsRegister3::getv4 (std::string name) const
{
    return boost::any_cast<glm::vec4>(get(name));
}
/***********************************************************************/
glm::mat3 ParamsRegister3::getm3 (std::string name) const
{
    return boost::any_cast<glm::mat3>(get(name));
}
/***********************************************************************/
glm::mat4 ParamsRegister3::getm4 (std::string name) const
{
    return boost::any_cast<glm::mat4>(get(name));
}
/***********************************************************************/
bool ParamsRegister3::getb (std::string name) const
{
    return boost::any_cast<bool>(get(name));
}
/***********************************************************************/
void ParamsRegister3::setOrModify (std::string name, boost::any value )
{
    // delete entry
    for (std::vector<property>::iterator it = mvProperties.begin(); it != mvProperties.end(); )
    {
        if ((*it).name == name)
            it = mvProperties.erase(it);
        else
            ++it;
    }
    // set entry
    property p(name, value);
    mvProperties.push_back( p);
}
/***********************************************************************/

test

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
 
std::cout << "BEGIN TEST PARAMSREGISTER3\n";
 
    ParamsRegister3 pr;
 
    int v0 = 10;
    pr.set("value1", v0);
    float v1 = 10.27;
    pr.set("value2", v1);
    glm::vec2 v2 (11.2, 12.3);
    pr.set("value3", v2);
    glm::vec3 v3 (11.3, 12.34, 5.55);
    pr.set("value4", v3);
    glm::vec4 v4 (11.2, 12.3, 66.6,77.7);
    pr.set("value5", v4);
    glm::mat3 m3 = glm::mat3();
    pr.set("value6", m3);
    glm::mat4 m4 = glm::mat4();
    pr.set("value7", m4);
    bool v5 = true;
    pr.set("value8", v5);
 
    float v6 = 12.44;
    pr.set("value2", v6);
 
    int o1 = pr.geti("value1");
    std::cout << "o1 = " << o1 << std::endl;
    float o2 = pr.getf("value2");
    std::cout << "o2 = " << o2 << std::endl;
    glm::vec2 o3 = pr.getv2("value3");
    std::cout << "o3 = " << o3.x << " " << o3.y << std::endl;
    glm::vec3 o4 = pr.getv3("value4");
    std::cout << "o4 = " << o4.x << " " << o4.y << " " << o4.z << std::endl;
    glm::vec4 o5 = pr.getv4("value5");
    std::cout << "o5 = " << o5.x << " " << o5.y << " " << o5.z << " " << o5.w << std::endl;
    glm::mat3 o6 = pr.getm3("value6");
    glm::mat4 o7 = pr.getm4("value7");
    bool o8 = pr.getb("value8");
    std::cout << "o8 = " << o8 << std::endl;
 
 
    std::cout << "END TEST PARAMSREGISTER3\n";

multimap :
.h

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
45
46
47
48
 
#ifndef PARAMSREGISTER4_H
#define PARAMSREGISTER4_H
/***********************************************************************/
#include <string>
#include <map>
#include <glm/glm.hpp>
/***********************************************************************/
class ParamsRegister4
{
public:
    ParamsRegister4();
    virtual ~ParamsRegister4();
 
    void set ( std::string name, int value) { mIntMap[name]=value; }
    void set ( std::string name, float value) { mFloatMap[name]=value; }
    void set ( std::string name, glm::vec2 value) { mVec2Map[name]=value; }
    void set ( std::string name, glm::vec3 value) { mVec3Map[name]=value; }
    void set ( std::string name, glm::vec4 value) { mVec4Map[name]=value; }
    void set ( std::string name, glm::mat3 value) { mMat3Map[name]=value; }
    void set ( std::string name, glm::mat4 value) { mMat4Map[name]=value; }
    void set ( std::string name, bool value) { mBoolMap[name]=value; }
    void set ( std::string name, std::string value) { mStringMap[name]=value; }
 
    int geti( std::string name) { return mIntMap[name]; }
    float getf( std::string name) { return mFloatMap[name]; }
    glm::vec2 getv2( std::string name) { return mVec2Map[name]; }
    glm::vec3 getv3( std::string name) { return mVec3Map[name]; }
    glm::vec4 getv4( std::string name) { return mVec4Map[name]; }
    glm::mat3 getm3( std::string name) { return mMat3Map[name]; }
    glm::mat4 getm4( std::string name) { return mMat4Map[name]; }
    bool getb( std::string name) { return mBoolMap[name]; }
    std::string gets( std::string name) { return mStringMap[name]; }
 
protected:
private:
    std::map<std::string, int> mIntMap;
    std::map<std::string, float> mFloatMap;
    std::map<std::string, glm::vec2> mVec2Map;
    std::map<std::string, glm::vec3> mVec3Map;
    std::map<std::string, glm::vec4> mVec4Map;
    std::map<std::string, glm::mat3> mMat3Map;
    std::map<std::string, glm::mat4> mMat4Map;
    std::map<std::string, bool> mBoolMap;
    std::map<std::string, std::string> mStringMap;
};
/***********************************************************************/
#endif // PARAMSREGISTER4_H

.cpp

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
 
#include "ParamsRegister4.h"
/***********************************************************************/
ParamsRegister4::ParamsRegister4()
{
    //ctor
}
/***********************************************************************/
ParamsRegister4::~ParamsRegister4()
{
    //dtor
}
/***********************************************************************/

test

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
45
46
 
std::cout << "BEGIN TEST PARAMSREGISTER4\n";
 
    ParamsRegister4 pr;
 
    int v0 = 10;
    pr.set("value1", v0);
    float v1 = 10.27;
    pr.set("value2", v1);
    glm::vec2 v2 (11.2, 12.3);
    pr.set("value3", v2);
    glm::vec3 v3 (11.3, 12.34, 5.55);
    pr.set("value4", v3);
    glm::vec4 v4 (11.2, 12.3, 66.6,77.7);
    pr.set("value5", v4);
    glm::mat3 m3 = glm::mat3();
    pr.set("value6", m3);
    glm::mat4 m4 = glm::mat4();
    pr.set("value7", m4);
    bool v5 = true;
    pr.set("value8", v5);
    std::string v51 = std::string ("string_test");
    pr.set("value9", v51);
 
    float v6 = 12.44;
    pr.set("value2", v6);
 
    int o1 = pr.geti("value1");
    std::cout << "o1 = " << o1 << std::endl;
    float o2 = pr.getf("value2");
    std::cout << "o2 = " << o2 << std::endl;
    glm::vec2 o3 = pr.getv2("value3");
    std::cout << "o3 = " << o3.x << " " << o3.y << std::endl;
    glm::vec3 o4 = pr.getv3("value4");
    std::cout << "o4 = " << o4.x << " " << o4.y << " " << o4.z << std::endl;
    glm::vec4 o5 = pr.getv4("value5");
    std::cout << "o5 = " << o5.x << " " << o5.y << " " << o5.z << " " << o5.w << std::endl;
    glm::mat3 o6 = pr.getm3("value6");
    glm::mat4 o7 = pr.getm4("value7");
    bool o8 = pr.getb("value8");
    std::cout << "o8 = " << o8 << std::endl;
    std::string o9 = pr.gets("value9");
    std::cout << "o9 = " << o9 << std::endl;
 
 
    std::cout << "END TEST PARAMSREGISTER4\n";

Merci pour l'aide, je passe en résolu.