Discussion :

[fafacpp]

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

.h

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

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

[Trademark]

Salut,

Code :

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

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 :

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

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

[SKone]

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

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

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

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

1
2
std::map< unsigned int, int > m_IntegerRegisters;
std::map< unsigned int, float > m_FloatRegisters;

Tu peux generaliser avec un:

Code cpp :

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

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

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

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

[Ehonn]

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

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

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

[fafacpp]

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

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

[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.

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

The following type, patterned after the OMG's Property Service, defines name-value pairs for arbitrary value types:

Code :

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

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.

[ternel]

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 :

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

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;
}

[fafacpp]

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 :

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

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

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

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

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

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

test

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