Dear All,

 

I’m trying to create a composite structure of flyweight inspired by the example boost_1_41_0\libs\flyweight\example\composite.cpp.

 

However, I need the leaf of my composite pattern to be a boost::fusion::map type. I’m getting the following error:

 

\boost\variant\variant.hpp(825) : error C3066: there are multiple ways that an object of this type can be called with these arguments

 

Is there any fundamental reason why the following code generate this error? The code compile when the leaf is a “struct” type rather than boost::fusion::map type.

 

Regards

Francois

 

 

 

#include <boost/flyweight.hpp>

#include <boost/functional/hash.hpp>

#include <boost/variant.hpp>

#include <boost/variant/apply_visitor.hpp>

#include <boost/variant/recursive_wrapper.hpp>

#include <boost/fusion/sequence.hpp>

#include <boost/fusion/container/map.hpp>

#include <iostream>

#include <string>

#include <vector>

 

using namespace boost::flyweights;

using boost::fusion::pair;

using boost::fusion::make_pair;

using boost::fusion::at_key;

 

// using boost::fusion::map

namespace leaf_key

{                     

    struct label;

}

typedef boost::fusion::map<pair<leaf_key::label,std::string>>  leaf;

 

struct portfolio;

 

typedef boost::variant<leaf,boost::recursive_wrapper<portfolio>> portfolio_variant;

 

typedef boost::flyweights::flyweight<portfolio_variant> portfolio_node;

 

struct portfolio:std::vector<portfolio_node>{};

 

struct portfolio_hasher: boost::static_visitor<std::size_t>

{

   std::size_t operator()(const leaf& f )const

   {

      boost::hash<std::string> h;

      // using boost::fusion::map

      std::string str = at_key<leaf_key::label>(f);

      // using struct

      //std::string str = f.label;

      return h(str);

   }

 

   std::size_t operator()(const boost::recursive_wrapper<portfolio>& pf_w)const

   {

      const portfolio& pf=pf_w.get();

      std::size_t res=0;

       for(portfolio::const_iterator it=pf.begin(),it_end=pf.end();it!=it_end;++it)

      {

         const portfolio_variant* p=&it->get();

         boost::hash_combine(res,p);

      }

      return res;

   }

};

 

std::size_t hash_value(const portfolio_variant& node)

{

   return boost::apply_visitor(portfolio_hasher(),node);

}

 

int main()

{

   return 0;

}