On 03/25/11 15:53, Noah Roberts wrote:

On 3/25/2011 1:48 PM, Noah Roberts wrote: [snip bad code]

I posted bits that I'd been experimenting and reverted stuff without testing. Here's corrected version:

template < typename Field > struct field_value { typedef Field field; typedef typename Field::type ftype; ftype value;

field_value(ftype const& t) : value(t) {} field_value() : value() {} };

template < typename Field, typename Params, typename Enable = void > struct initializer { static typename Field::type apply(Params &) { return Field::type(); } }; template < typename Field, typename Params > struct initializer >::type > { static typename Field::type apply(Params & params) { return get<Field>(params); } };

template < typename FieldValue, typename Params > FieldValue init_field(Params & pars) { return initializer::apply(pars); }

template < typename FieldValue, typename More > struct record_base : FieldValue, More { template < typename Params > record_base(Params & pars) : FieldValue(init_field<FieldValue>(pars)) , More(pars) {}

record_base() : FieldValue(), More() {} }; struct empty_record_base { template < typename Ignored > empty_record_base(Ignored&){} empty_record_base() {} };

template < typename MplSequence > struct build_record { typedef boost::mpl::placeholders::_1 _1; typedef boost::mpl::placeholders::_2 _2;

typedef typename boost::mpl::fold < MplSequence , empty_record_base , record_base< field_value<_2>, _1 > >::type type;

// type should be record_base< field_value<field0> // , record_base< field_value<field1> // , ... // , record_base // > ... // };

Hi Noah, After comparing with Section 9.5 of the MPL book, it seems the correspondence between this code and the book's is: this_code the book --------- ---------- empty_record_base empty_base field_value wrap record_base inherit and the major difference is is field_value, which, I suppose will be used (after possibly some modification) to allow a non-copyable member. Is that right? Since record_base has no constructor taking this into account, I'm guessing you're really asking how to create such a constructor and maybe modifications to field_value to make this possible. Right? -regards, Larry BTW, there's no get template defined above. I assume it will be something like the get on p. 192 of the book?

On 04/03/11 13:59, Larry Evans wrote:

On 03/25/11 15:53, Noah Roberts wrote:

...

On 3/25/2011 1:48 PM, Noah Roberts wrote: [snip bad code]

I posted bits that I'd been experimenting and reverted stuff without testing. Here's corrected version: [snip] Hi Noah,

Are you having any luck with this? I'd liks to see how you've done it and/or what difficulties you had doing it.

TIA.

-Larry

The code here: http://svn.boost.org/svn/boost/sandbox/variadic_templates/libs/composite_sto... has non-copyable template classes: template < unsigned I

struct charvec_double : charvec_u<I> { double d; charvec_double() : d(-1000.0-double(I)) {} charvec_double(char c) : charvec_u<I>(c) , d(-100.0-double(I)) {} charvec_double(double _d) : d(_d) {} charvec_double(char c,double _d) : charvec_u<I>(c) , d(_d) {} private: charvec_double(charvec_double const&) /**@brief * Disallow copy CTOR */ ; }; used as components in a heterogeneous container type: typedef pack::indexed_ctor_args_all_of_aligned < mpl::integral_c , charvec_double<0> , charvec_double<1> , charvec_double<2> , charvec_double<3> > tagged_type ; and initialized, without using the copy CTOR's. Instead, it uses something like the named parameters syntax: http://en.wikipedia.org/wiki/Named_parameter where, in this case, the name for the parameters is their index template: index In the test code mentioned, this appears as: index < index_numerals , index_0 > ndx0 ; index < index_numerals , index_3 > ndx3 ; tagged_type tagged_arg ( ndx3=double(1000.3) //show out-of-order initialization , ndx0='x' #if 1 , index() = 'z' #else //This should produce compile-time error because of multiple index_0 associations. , ndx0='z' #endif ) ; Note the #else comments. If the same name is used more than once, a compile error (obscure, as usual) is produced. The output produced from the following print statements are: :project=charvec_double<0>:id_get=12:v[0]=x:d=-100 :project=charvec_double<1>:id_get=13:v[0]=a:d=-1001 :project=charvec_double<2>:id_get=14:v[0]=z:d=-102 :project=charvec_double<3>:id_get=15:v[0]=a:d=1000.3 Of course, in real code, the index_numerals would have more meaningful names. The heart of the solution is in: http://svn.boost.org/svn/boost/sandbox/variadic_templates/boost/composite_st... in templated CTOR: template < index_type... Keys , typename... CtorTypes > indexed_ctor_args_all_of_aligned ( index_component < index_type , Keys , CtorTypes >const&... ctor_args ) Here, the Keys... are the indices, and the CtorTypes... are the types of arguments to the components associated with the corresonding key in Keys.... The value of those componens are, obvious, retrieved using the my_comp member variable of the index_component values. HTH. -Larry