Bonsoir,
Je suis en train de créer une classe mère qui s'occupe de gèrer mes modèles :

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
#ifndef __ABSTRACTMODEL_H__
#define __ABSTRACTMODEL_H__
 
#include <string>
#include <vector>
 
#include <boost/property_tree/ptree.hpp>
 
class AbstractModel
{
public:
    AbstractModel();
    virtual ~AbstractModel();
 
    void LoadFromFile(const std::string& path);
    void LoadFromName(const std::string& name);
 
    static std::vector<std::string> GetAvaibleModels();
 
protected:
    virtual void parse(boost::property_tree::ptree data) = 0;
 
    // functions related to files location
    static std::string basedir();
    static std::string filename();
};
 
#endif // __ABSTRACTMODEL_H__
Voici son implémentation :

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
#include "AbstractModel.h"
 
#include <boost/filesystem.hpp>
#include <boost/property_tree/info_parser.hpp>
 
AbstractModel::AbstractModel()
{
 
}
 
AbstractModel::~AbstractModel()
{
 
}
 
void AbstractModel::LoadFromFile(const std::string& path)
{
    boost::property_tree::ptree data;
    read_info(path, data); 
 
    parse(data);
}
 
void AbstractModel::LoadFromName(const std::string& name)
{
    namespace fs = boost::filesystem;
 
    fs::path location = fs::path(basedir()) / name / filename();
    LoadFromFile(location.string());
}
 
std::vector<std::string> AbstractModel::GetAvaibleModels()
{
    namespace fs = boost::filesystem;
 
    std::vector<std::string> results;
 
    for(fs::directory_iterator it(basedir()); it != fs::directory_iterator(); ++it)
    {
        if(fs::is_directory(*it))
            results.push_back(it->path().string());
    }
}
 
std::string AbstractModel::basedir()
{
    return "models";
}
 
std::string AbstractModel::filename()
{
    return "model.info";
}
Comme vous le devinez, j'ai besoin que basedir() et éventuellement filename() soient redéfinis par chaque classe fille qui représentera un modèle (PersonnageModel, ArmeModel, etc...) pour ne pas que les modèles soient mélangés.

Cepedant, lorsque je redéfini basedir() dans la classe fille BlockModel, l'appel à LoadFromName("test") va me chercher le fichier du modèle par défaut, à savoir models/test/model.info et non pas blocks/test/model.info.

Je ne vois pas comment faire pour que chaque classe fille aie son propre dossier et que cela soit directement gèré par la classe mère.

Auriez-vous des (belles) solutions à me proposer ? À la base je voulais définir ces constantes spécifiques comme ça pour faire plus propre :

Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
namespace
{
    const std::string MODEL_BASEDIR = "blocks";
}
Il faudrait que cette variable soit également accessible pour les méthodes statiques telles que GetAvaibleModels().

Merci d'avance, darkrojo.