Re: [boost] [flyweight][parameter] is there an interest in this template parameter expresion

From: David Abrahams (dave_at_[hidden])
Date: 2008-07-15 22:57:13

on Mon Jul 14 2008, "vicente.botet" <vicente.botet-AT-wanadoo.fr> wrote:

> Hello,
>
> I'm doing a Locally Unique Identifier generator library. The DSL
> grammar is quite complex, so the use of optional class parameters
> seams unavoidable. I have started to use the Boost.Parameter Library
> as the Boost.Flyweight does.

I'm not familiar with Flyweight.

> The flyweight class that takes 5 optional parameters and is currently
> declared as follows
>
> <code>
> template<
>  typename T,
>  typename Arg1,typename Arg2,typename Arg3,typename Arg4,typename Arg5
> /**/>

I think there must be defaults for these arguments, probably
parameter::void_, yes?

> class flyweight
> {
> private:
>  typedef parameter::parameters<
>    parameter::optional<
>      parameter::deduced<tag<> >,
>      detail::is_tag<boost::mpl::_>
>    >,
>    parameter::optional<
>      parameter::deduced<tracking<> >,
>      is_tracking<boost::mpl::_>
>    >,
>    parameter::optional<
>      parameter::deduced<factory<> >,
>      is_factory<boost::mpl::_>
>    >,
>    parameter::optional<
>      parameter::deduced<locking<> >,
>      is_locking<boost::mpl::_>
>    >,
>    parameter::optional<
>      parameter::deduced<holder<> >,
>      is_holder<boost::mpl::_>
>    >
>  >                                            signature;
>  typedef typename signature::bind<
>    Arg1,Arg2,Arg3,Arg4,Arg5
>  >::type                                      args;
>  typedef typename parameter::binding<
>    args,tag<>,mpl::na
>  >::type                                      tag_type;
>  typedef typename parameter::binding<
>    args,tracking<>,refcounted
>  >::type                                      tracking_policy;
>  typedef typename parameter::binding<
>    args,factory<>,hashed_factory<>
>  >::type                                      factory_specifier;
>  typedef typename parameter::binding<
>    args,locking<>,simple_locking
>  >::type                                      locking_policy;
>  typedef typename parameter::binding<
>    args,holder<>,static_holder
>  >::type                                      holder_specifier;
>
>  typedef parameter::parameters<
>    parameter::optional<
>      parameter::deduced<
>        detail::unmatched_arg
>      >,
>      mpl::not_<
>        mpl::or_<
>          detail::is_tag<boost::mpl::_>,
>          is_tracking<boost::mpl::_>,
>          is_factory<boost::mpl::_>,
>          is_locking<boost::mpl::_>,
>          is_holder<boost::mpl::_>
>        >
>      >
>    >
>  >                                            unmatched_signature;
>  typedef typename unmatched_signature::bind<
>    Arg1,Arg2,Arg3,Arg4,Arg5
>  >::type                                      unmatched_args;
>  typedef typename parameter::binding<
>    unmatched_args,detail::unmatched_arg,
>    detail::unmatched_arg
>  >::type                                      unmatched_arg_detected;
>  BOOST_STATIC_ASSERT((

Should use one of the MPL assertions, but anyway...

>    /* You have passed a type in the specification of a flyweight type that
>     * could not be interpreted as a valid argument.
>     */
>    is_same<unmatched_arg_detected,detail::unmatched_arg>::value));
> ...
> </code>
>
> I have made abstraction of the common structure of this code resulting
> on a 'expr' class.
> The boost::dsl::expr class has three parameters:
> * a tag for the expression
> * a vector of parameters specification, each one been either mandatory
> or optional, and containing a tag, a predicate stating if a parameter
> corresponds to the tag, and a default value for the optionals
> * a vector of the current parameters
>
> The parameter associated to a given tag can be obtained using the get
> template function. For example to get the tracking parameter we can
> use:
>
>    typename base_type::template get<tracking<> >::type
>
> All the implementation details are encapsulated on the expre class.
>
> The flyweight class can then be rewriten as:
>
> <code>
<schnipp>
> </code>
>
> BOOST_FLYWEIGHT_BASE is used to avoid repeating the long template expression

Rewriting so I can grok it...

template <
    class T
  , class Arg1, class Arg2, class Arg3, class Arg4,class Arg5
>
struct flyweight_base
{
    typedef dsl::expr<
        flyweight<T>
      , mpl::vector<
            dsl::optional<tag<>, detail::is_tag<mpl::_>,   mpl::na >
          , dsl::optional<tracking<>, is_tracking<mpl::_>, refcounted >
          , dsl::optional<factory<>,  is_factory<mpl::_>,   hashed_factory<> >
          , dsl::optional<locking<>,  is_locking<mpl::_>,   simple_locking >,
          , dsl::optional<holder<>,    is_holder<mpl::_>,   static_holder >
        >
      , mpl::vector<Arg1,Arg2,Arg3,Arg4,Arg5>
    > type;
};

template<
 typename T,
 typename Arg1,typename Arg2,typename Arg3,typename Arg4,typename Arg5
>
class flyweight : public flyweight_base<T,Arg1,Arg2,Arg3,Arg4,Arg5>::type
{
   typedef flyweight_base<T,Arg1,Arg2,Arg3,Arg4,Arg5>::type base_type;

    typedef typename base_type::template get< tag<> >::type tag_type;
    typedef typename base_type::template get< tracking<> >::type tracking_policy;
    typedef typename base_type::template get< factory<> >::type
    factory_specifier;
    typedef typename base_type::template get< locking<> >::type locking_policy;
    typedef typename base_type::template get< holder<> >::type holder_specifier;
// ...
};

So, what benefit, exactly, is the framework providing (e.g. is it
providing the equivalent of the static assertion in the original code?),
and what is the purpose of using derivation above?

> I would like to know if there is an interest in such a class, and if
> it could be added to the parameters library?

Anything that makes declaring parameter-enabled classes simpler would be
a welcome addition.  However, I'm not yet sure what this is doing ;-)

-- 
Dave Abrahams
BoostPro Computing
http://www.boostpro.com