convertir génériquement de boost :: variant <T> en type

Question

J'ai un typedef boost::variant<int, float, double, long, bool, std::string, boost::posix_time::ptime> variant que j'utilise pour stocker différents types de valeurs dans un struct. Un seul du type spécifique va jamais être stocké dans cette structure, mais j'ai un vecteur de ces structs que j'ai besoin de passer en revue et d'obtenir le type réel de la variante.

Maintenant, quand je dois faire la conversion des types de cette variante je fais ceci:

variant second = mystruct.variant; 
           if (second.which() == 5) //string 
        { 
         std::string val = boost::get<std::string>(second); 
         modvalue->AddNodeAttribute(key, val); 
        } 
        else if (second.which() == 0) //int 
        { 
         int val = boost::get<int>(second); 
         modvalue->AddNodeAttribute(key, val); 
        } 
        else if (second.which() == 2) //double 
        { 
         double val = boost::get<double>(second); 
         modvalue->AddNodeAttribute(key,val); 
        } 
        else if (second.which() == 1) //float 
        { 
         float val = boost::get<float>(second); 
         modvalue->AddNodeAttribute(key, val); 
        } 
        else if (second.which() == 3) // long 
        { 
         long val = boost::get<long>(second); 
         modvalue->AddNodeAttribute(key, val); 
        } 
        else if (second.which() == 4) // bool 
        { 
         bool val = boost::get<bool>(second); 
         modvalue->AddNodeAttribute(key, val); 
        } 
        else if (second.which() == 6) // posix::time 
        { 
         boost::posix_time::ptime ptm = boost::get<boost::posix_time::ptime>(second); 
         modvalue->AddNodeAttribute(key, ptm); 
        } 

Je me demandais s'il y a une façon plus générique que je peux contourner le faire en écrivant une fonction générique prend la variante et un type T qui est la valeur de retour. Mais quand je fais cela, je dois encore écrire un tas d'instructions if pour tenir compte de chaque type de T.

donc quelque chose comme FromVariant<int>(var);, mais alors je devrais encore le faire pour chaque type dans ma variante.

Il semble donc que ma solution générique ne réduit pas mon code, mais l'augmente, ce qui n'est évidemment pas le cas. Je me demandais si quelqu'un avait une solution plus élégante pour obtenir les différents types de ma variante qui est quelque peu générique, où je peux simplement appeler une fonction donnant le type que je veux en arrière?

Answer 1

regardant fait votre code un peu plus, voici une autre option - encore une fois basée sur l'utilisation de visiteurs ..

struct add_node_visitor : boost::static_visitor<> 
{ 
    add_node_visitor(<type of modvalue> & node, <type of key> & key) : _node(node), _key(key) {} 

    template <typename _Item> 
    void operator()(_Item const& item) 
    { 
    node->AddNodeAttribute(_key, item); 
    } 

    <type of modvalue> & _node; 
    <type of key> & _key; 
} 

à utiliser:

boost::apply_visitor (add_node_visitor(modmodvalue, key), mystruct.variant); 

Tant que votre AddNodeAttribute a pour surcharge tous les types, ce qui précède devrait fonctionner ...

Answer 2

Lorsque j'utilisais boost::variant, j'accédais toujours aux données contenues en utilisant la technique du visiteur. À mon avis, c'est un moyen très élégant. Il ne repose pas sur la logique de commutation, ce qui est vraiment un signe de mauvaise conception. Voir le documentation.

Bonne chance!

Answer 3

... Que fait AddNodeAttribute? Fondamentalement la même chose pour chaque type, non? Si vous avez un conteneur d'attributs de noeud quelque part, alors il doit fondamentalement être un conteneur du type variant, non? ... pourquoi ne pas simplement réécrire AddNodeAttribute pour être une seule fonction acceptant une variante?