Combining Policy Classes - Template Template Parameters & Variadic Templates

Question

I am wondering if it's possible to combine policy classes using variadic template-template parameters such that each policy may have it's own template pack. It seems like you can only share a single template pack amongst all policies but I hope that's not the case.

The following seems to be what's possible:

template <
    class T,
    template <class, typename...>   class Policy1,
    template <class, typename...>   class Policy2,
    template <class, typename...>   class Policy3,
    typename... Args    
>
struct PolicyClass 
    : public Policy1     <ObjT, Args...>
    , public Policy2     <ObjT, Args...>
    , public Policy3     <ObjT, Args...>    {}

I'm hoping each policy can have it's own pack so I could make something like this (?):

template <class T>
struct implementedPolicy1 {};
template <class T>
struct implementedPolicy2 {};
template <class T, class A>
struct implementedPolicy3 {};

PolicyClass <ObjT, 
             implementedPolicy1,
             implementedPolicy2,
             implementedPolicy3<AType>
            >

The idea being each of the policies are all using the same object type but the third has some further templating. I know that's incorrect code above - just trying to illustrate what I'd like to be able to do.

Thanks

What's `ObjT` ? The current class ? – Matthieu M. Feb 21 '14 at 16:40 — Matthieu M., Feb 21 '14 at 16:40

score 3 · Answer 1 · answered Feb 21 '14 at 16:44

3

I have never been fan of template template parameters, and this is one other instance I would avoid them:

template <typename T, typename... Policies>
struct PolicyClass: Policies... {};

will just work with arbitrary policies:

using PC = PolicyClass<int,
                       LifetimePolicy<LP::Extended>,
                       DurabilityPolicy<3600, DP::Seconds>
                       StoragePolicy<int, SP::InMemory>>;

answered Feb 21 '14 at 16:44

Matthieu M.

287,565
48
449
722

Thanks @Matthieu That would be useful in some cases. For this particular instance I want specifically 3 policies at all times since functions of the policies are used in a PolicyClass member function. – scmcduffee Feb 21 '14 at 17:06
You can actually use an unbounded number of policies with variadic templates; as long as they have a uniform interface. If you wish to restrict it to 3 though, `template struct PC: P1, P2, P3 {};` works very well too. – Matthieu M. Feb 21 '14 at 17:41

score 1 · Answer 2 · answered Feb 21 '14 at 16:22

Note that you may have something like:

template <class T,
          template <class> class Policy1,
          template <class> class Policy2,
          template <class> class Policy3>
struct PolicyClass : public Policy1<ObjT>,
                     public Policy2<ObjT>,
                     public Policy3<ObjT>
{};

template <class T> struct implementedPolicy1 {};
template <class T> struct implementedPolicy2 {};
template <class T, class A> struct implementedPolicy3 {};

// Adapt the policy interface
template <class T>
using myImplementedPolicy3 = implementedPolicy3<T, AType>; // Assuming AType exist

PolicyClass <ObjT, implementedPolicy1, implementedPolicy2, myImplementedPolicy3> policies;

Yakk - Adam Nevraumont · Accepted Answer · 2014-02-21T17:40:56.090

You need to be able to delimit between the packs.

// helper template.  Using `std::tuple<>` instead is another option.
template<class...>struct type_list {};

// base, note no body:
template <
    class T,
    template <class, typename...>   class Policy0,
    template <class, typename...>   class Policy1,
    template <class, typename...>   class Policy2,
    typename... Packs
>
struct PolicyClass;

// specialization:
template <
    class T,
    template <class, typename...>   class Policy0,
    template <class, typename...>   class Policy1,
    template <class, typename...>   class Policy2,
    typename... A0s,
    typename... A1s,
    typename... A2s
>
struct PolicyClass<
  T, Policy1, Policy2, Policy3,
  type_list<A0s...>, type_list<A1s...>, type_list<A2s...>
>
: Policy0<T, A0s...>, Policy1<T, A1s...>, Policy2<T, A2s...> {}

where I pack each policies extra arguments into a type_list.

In theory you could do fancier things, like have particular "tag" types being the delimiters, but it ends up being a lot of gymnastics.

PolicyClass< int, bob, eve, alice, type_list<>, type_list<double>, type_list<char, char, char> > foo;

will create

PolicyClass: bob<int>, alice<int, double>, eve<int, char, char, char>

roughly.

Thanks @Yakk - How would I go about using this then? – scmcduffee Feb 21 '14 at 17:22 — scmcduffee, Feb 21 '14 at 17:22

Combining Policy Classes - Template Template Parameters & Variadic Templates

3 Answers3