boost-mpl

I want to be able to pass an integer or a double (or a string) as a template argument and in some instances convert the result to an integer and use it as a template argument for a type in the class. Here's what I've tried: template <typename MPLString> class A { // the following works fine int fun() { // this function should return the int in the boost mpl type passed to it // (e.g. it might be of the form "123") return std::stoi(boost::mpl::c_str<MPLString>::value); } // the following breaks because std::stoi is not constexpr std::array<int, std::stoi(boost::mpl::c_str<MPLString>::value)>

I have the following templated class structure struct TraitA{}; struct TraitB{}; template<typename trait> struct FunctionalityA{}; template<typename trait> struct FunctionalityB{}; template<typename Func> struct FuncUserA{}; template<typename Func> struct FuncUserB{}; template<typename fuser> struct Host{}; The Host class can now how have the following types. typedef Host<FuncUserA<FunctionalityA<TraitA> > > Host1_t; typedef Host<FuncUserA<FunctionalityA<TraitB> > > Host2_t; typedef Host<FuncUserA<FunctionalityB<TraitA> > > Host3_t; typedef Host<FuncUserA<FunctionalityB<TraitB> > > Host4_t;

The boost::mpl algorithms seem not to be able to work on std::tuple types out of the box, e.g., the following does not compile (boost-1.46.0, g++ snapshot 2011-02-19): #include <tuple> #include <boost/mpl/vector.hpp> #include <boost/mpl/contains.hpp> namespace mpl=boost::mpl; typedef mpl::vector<int,float,bool> types; static_assert(mpl::contains<types, float>::value, "vector contains bool"); typedef std::tuple<int,float,bool> types2; // the following does not compile: // error: no class template named ‘apply’ in ‘struct boost::mpl::contains_impl<boost::mpl::non_sequence_tag>’ static_assert(mpl

Consider the following header file: // Foo.h class Foo { public: template <typename T> void read(T& value); }; I want to explicitly instantiate the Foo::read member function template in a source file for all types included in a boost::mpl::vector : // Foo.cc #include <boost/mpl/vector.hpp> #include <boost/mpl/begin_end.hpp> #include "Foo.h" template <typename T> void Foo::read(T& value) { /* do something */ } typedef boost::mpl::vector<int, long, float> types; // template Foo::read<int >(int&); // template Foo::read<long >(long&); // template Foo::read<float>(float&); // instantiate

I look at this grate code based on boost.Any and cant help but wonder if we could use Boost.Variant instead. I wonder if such API would be possible: void voidFunc() { std::cout << "void called" << std::endl; } int stringFunc(std::string str) { std::cout << str << std::endl; return 0; } int main() { some_map_like_type<std::string, boost::variant> funcs; funcs.insert<void , void >("voidFunc", &voidFunc)); // now our variant vould contain something like boost::function<void, void> funcs.insert<int , std::string>("stringFunc", &stringFunc)); // and now we added to our variant a new type: boost:

Is it possible to get at the offset of a mpl::vector after performing a mpl::find<seq,type> on it ? Put differently I want to do the compile time equavalent of: #include <vector> #include <algorithm> #include <iostream> int main() { typedef std::vector<int> v_type; v_type v_int(3); v_int[0] = 1; v_int[1] = 2; v_int[2] = 3; v_type::iterator it= std::find( v_int.begin() ,v_int.end(),3); std::cout << it - v_int.begin() << std::endl; } Failing this, my types in mpl::vector have a type_trait<T>::ordinal const hard-coded, I would like to avoid this if possible. Important Note , I am also creating a

I want to multiply each element in an mpl::vector by an int . First, a metafunction to multiply an int_ with an int . template <int i> struct multiply_scalar { template<typename T> struct apply { typedef int_<(T::value * i)> type; }; }; Here are the calls I want to make. typedef vector<int_<3>, int_<4> > my_vec; typedef typename transform< my_vec, multiply_scalar<2> >::type my_vec_2; typedef vector<int_<6>, int_<8> > my_vec_3; BOOST_MPL_ASSERT(( boost::is_same< my_vec_2, my_vec_3 > )); //Fails //type of my_vec2 is: boost::mpl::v_item<mpl_::int_<8>, boost::mpl::v_item<mpl_::int_<6>, boost::mpl: