Discussion :

[m0ul3sh0t]

Bonjour à tous,

J'ai découvert il y a peu les variants de boost et j'ai défini le type suivant :

Code :

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

typedef boost::make_recursive_variant<bool, int, size_t, std::string, time_t, unsigned int, unsigned long long, std::map<std::string, boost::recursive_variant_>, std::vector<std::string>>::type		Value;

J'utilisais ce type comme par exemple avec une map de type

Code :

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

std::map<std::string, Value>

et où j'accède aux données de la façon suivante

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
	for (const auto &data : datas)	{
		if (data.second.type() == typeid(bool))										root[data.first] = boost::get<bool>(data.second);
		else if (data.second.type() == typeid(int))									root[data.first] = boost::get<int>(data.second);
		else if (data.second.type() == typeid(size_t))								root[data.first] = static_cast<uint64_t>(boost::get<size_t>(data.second));
		else if (data.second.type() == typeid(std::string))							root[data.first] = boost::get<std::string>(data.second);
		else if (data.second.type() == typeid(time_t))								root[data.first] = static_cast<int64_t>(boost::get<time_t>(data.second));
		else if (data.second.type() == typeid(unsigned int))						root[data.first] = boost::get<unsigned int>(data.second);
		else if (data.second.type() == typeid(unsigned long long))					root[data.first] = boost::get<uint64_t>(data.second);
		else if (data.second.type() == typeid(std::map<std::string, Value>))		root[data.first] = this->convertDataToJson(boost::get<std::map<std::string, Value>>(data.second));
		else if (data.second.type() == typeid(std::vector<std::string>))			root[data.first] = this->convertDataToJson(boost::get<std::vector<std::string>>(data.second));
		else	{
			Utils::log(Logger::LEVEL::WARN, "Type not found for key [%s]", data.first.c_str());
		}

Sauf que par la suite, je me suis rendu compte qu'en plus d'un vector de string, j'ai besoin d'un vector de map<std::string, std::string>. J'ai essayé de modifier mon type comme suit

Code :

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

typedef boost::make_recursive_variant<bool, int, size_t, std::string, time_t, unsigned int, unsigned long long, std::map<std::string, boost::recursive_variant_>, std::vector<boost::recursive_variant_>>::type		Value;

mais quand je tente d'utiliser mon type Value, j'ai une erreur...


Je m'explique...
1) J'ai une classe Dto où j'ai 3 méthodes pour ajouter des data

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
class	 Dto
{
/* Attributs */
	...
	std::map<std::string, Value>				_data;
 
 
/* Methods */
public:
	...
	/* Setters */
	void										setData(const std::map<std::string, std::string> &data);
	void 										setData(const std::pair<std::string, Value> &data);
	void										setData(const std::string &key, const Value &value);

2) J'ai une classe EventPlayDoneDto qui hérite de ma classe Dto où je souhaite ajouter une vecteur de strings

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
class EventPlayDoneDto : public Dto
{
/* Methods */
public:
	...
	void												setPlayedFiles(const std::vector<std::string> &files);
};
 
//----------------------------------
void											EventPlayDoneDto::setPlayedFiles(const std::vector<std::string> &files)
//----------------------------------
{
	this->setData("files", files);
}

Au moment de compiler, j'obtiens l'erreur suivante

Code :

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

1
2
3
eventplaydonedto.cpp: In member function ‘void EventPlayDoneDto::setPlayedFiles(const std::vector<std::basic_string<char> >&)’:
eventplaydonedto.cpp:49:30: error: no matching function for call to ‘EventPlayDoneDto::setData(const char [6], const std::vector<std::basic_string<char> >&)’
  this->setData("files", files);

Je ne vois pas ce que j'ai raté...

Est-ce que mon nouveau type Value vous semble correct? et qu'est ce que j'ai pu faire de travers?

[m0ul3sh0t]

Je viens de procéder à un test tout simple

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
#include <boost/variant.hpp>
#include <map>
#include <vector>
 
typedef boost::make_recursive_variant<bool, int, size_t, std::string, time_t, unsigned int, unsigned long long, std::map<std::string, boost::recursive_variant_>, std::vector<boost::recursive_variant_>>::type         Value;
 
int main(int ac, char **av)
{
        std::vector<std::string>                files;
        files.push_back("1.pcm");
        files.push_back("2.pcm");
 
        std::map<std::string, Value>            tmp;
        tmp.insert(std::pair<std::string, Value>("files", files));
 
        std::vector<Value>                      values;
        values.push_back(tmp);
        return 1;
}

Et j'obtiens l'erreur suivante

Code :

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

1
2
test.cpp:15:57: error: no matching function for call to ‘std::pair<std::basic_string<char>, boost::variant<boost::detail::variant::recursive_flag<bool>, int, long unsigned int, std::basic_string<char, std::char_traits<char>, std::allocator<char> >, long int, unsigned int, long long unsigned int, std::map<std::basic_string<char, std::char_traits<char>, std::allocator<char> >, boost::recursive_variant_, std::less<std::basic_string<char, std::char_traits<char>, std::allocator<char> > >, std::allocator<std::pair<const std::basic_string<char, std::char_traits<char>, std::allocator<char> >, boost::recursive_variant_> > >, std::vector<boost::recursive_variant_, std::allocator<boost::recursive_variant_> > > >::pair(const char [6], std::vector<std::basic_string<char> >&)’
  tmp.insert(std::pair<std::string, Value>("files", files));

L'ajout de mon vector<std::string> dans ma map ne passe pas...



Je viens de prendre l'exemple du tutorial

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
typedef boost::make_recursive_variant<
      int
    , std::vector< boost::recursive_variant_ >
    >::type int_tree_t;
 
std::vector< int_tree_t > subresult;
subresult.push_back(3);
subresult.push_back(5);
 
std::vector< int_tree_t > result;
result.push_back(1);
result.push_back(subresult);
result.push_back(7);
 
int_tree_t var(result);

En fait, si je change la variable subresult en std::vector<int>, j'obtiens exactement la même erreur
Pourquoi est-ce qu'un vecteur/map de mon type variant ne peut pas valoir un vecteur/map d'un type bien défini?

[Invité]

Bonjour,

Pourquoi est-ce qu'un vecteur/map de mon type variant ne peut pas valoir un vecteur/map d'un type bien défini?

Pas exactement.

Les éléments std::vector<boost::recursive_variant_> sont assimilables à std::vector<Value>. Pas std::vector<bool>, std::vector<std::string>, etc.
Et quels que soient les types U != T, tu ne peux pas passer directement d'un std::vector<U> à std::vector<T>, même s'il existe une conversion implicite entre U et T.

Tu dois donc utiliser std::vector<Value> à la place :

Code :

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

1
2
3
4
5
6
std::vector<Value> files;
files.emplace_back("1.pcm");
files.emplace_back("2.pcm");
 
std::map<std::string, Value> tmp;
tmp.emplace("files", files); // OK : construction d'un Value à partir d'un std::vector<Value>

Ou si tu pars d'un std::vector<std::string>, d'abord le convertir en std::vector<Value> :

Code :

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

1
2
3
4
void EventPlayDoneDto::setPlayedFiles(const std::vector<std::string> &files)
{
    setData("files", std::vector<Value>(files.begin(), files.end())); // OK : construction de chaque Value à partir de std::string
}

Le même principe s'applique pour std::map.

Sinon, à la place de tes if/else if, utilise plutôt boost::apply_visitor.

[m0ul3sh0t]

Hum donc en gros, soit je traite uniquement avec des std::vector<Value> soit je reconstruis mon vector au moment d'ajouter mon vector<std::string>. Merci

Je vais regarder la notion de boost::apply_visitor

[koala01]

Salut,

A vrai dire, j'ai un léger problème de compréhension de ton besoin

Si j'arrive à comprendre pourquoi tu souhaites avoir un variant qui puisse être de type bool, int, unsigned int , string et time_t (*), j'ai beaucoup de mal à imaginer une situation dans laquelle ces types "simples" devraient pouvoir cohabiter avec des types aussi complexes que des std::map<x, y> ou des std::vector<z>.

C'est surement dut au fait que j'ai, de manière générale, une sainte horreur de la notion même de variant et que je n'y ai recours que lorsque je n'ai pas d'autre choix (lorsque je veux pouvoir sérialiser une configuration complexe, par exemple), en veillant toujours à retomber le plus vite possible sur des données de types clairement définis afin de pouvoir abandonner mes variants.

Mais donc la question qui me brule les lèvre est "quel est donc ce besoin qui t'incite à faire cohabiter des types à ce point dissemblables "

Car, si j'ai bien compris, tu devrais aussi envisager d'ajouter le support de std::vector<std::byte>, voir même d'autres collections de std::byte à la liste des types supportés par ton variant

(*) fais attention au fait que size_t est en réalité un alias de type sur un des type entier non signés (unsigned int, unsigned long ou unsigned long long, selon le système utilisé), et qu'il n'y aura donc -- a priori -- aucune différence entre l'alias de type et le "type original"