Variadic Inheritance

Question

Consider this code:

#include <iostream>

class Religion {
    public:
        virtual void pray() = 0;
};

// Example:  Denomination<N0,N1,N2,N3> is derived from Denomination<N0,N1,N2> is derived
// from Denomination<N0,N1> is derived from Denomination<N0> is derived from Religion.
template <int...> class Denomination : public Religion {
    virtual void pray() {std::cout << "Prays like a ... ?\n";}
};

template <> class Denomination<2> : public Religion {
    virtual void pray() override {std::cout << "Prays like a Muslim.\n";}
};

template <> class Denomination<2,0> : public Denomination<2> {
    virtual void pray() override {std::cout << "Prays like a Sunni Muslim.\n";}
};

template <> class Denomination<2,0,1> : public Denomination<2,5> {
    virtual void pray() override {std::cout << "Prays like a Hanafi Sunni Muslim.\n";}
};

template <int...> struct D {};

class Person {
    Religion* religion;
public:
    template <int... Is>
    Person (const D<Is...>&) : religion(new Denomination<Is...>) {} 
        // How to get the Flyweight Pattern here?
    void pray() {religion->pray();}
};

int main() {
    Person* person1 = new Person(D<2,0,1>{});  // "Prays like a Hanafi Sunni Muslim."
    Person* person2 = new Person(D<2,0>{});  // "Prays like a Sunni Muslim."
    Person* person3 = new Person(D<2>{});  // "Prays like a Muslim."
    person1->pray();
    person2->pray();
    person3->pray();

    Person* person4 = new Person(D<2,5,6,2,1,3>{});
    person4->pray();  // Should be "Prays like a Hanafi Sunni Muslim."
}

So I want to change the Person constructor to

Person (const D<Is...>&) : religion(findDenomination<Is...>()) {}

which will look up a "table" of static Religion*s. After all, 2 people belonging to the exact same denomination should share the same Religion* value. So it's the flyweight design pattern I'm trying to implement here. The problem is that we don't know long the Is... pack is (the number of sub-sub-...-denominations is not fixed anywhere), so a simple multi-dimensional array won't work I don't think. So instead what I'm doing is placing some static const vectors of Religion*s in appropriate classes and the Is... pack will be used to find the final vector to look up.

Update: Any better ways to do this? The solution I found so far has a major drawback if you see below.

Answer 1

Ok, I've worked out almost a complete solution. Person* person4 = new Person(D<2,0,1,2,1,3>{}); is not working anymore though. This person is supposed to be a sub-sub-category of a Hanafi Sunni Muslim, which is supposed to default to praying like a Hanafi Sunni Muslim due to (intentional) lack of overriding for Denomination<2,0,1,2,1,3>.

#include <iostream>
#include <vector>
#include <type_traits>

class Religion {
    public:
        virtual void pray() = 0;
};

template <int...> class Denomination : public Religion {
    virtual void pray() {std::cout << "Prays like a ... ?\n";}
};

template <> class Denomination<0> : public Religion {
    virtual void pray() override {std::cout << "Prays like a Christian.\n";}
};

template <> class Denomination<0,0> : public Denomination<0> {
    virtual void pray() override {std::cout << "Prays like a Catholic.\n";}
};

template <> class Denomination<0,1> : public Denomination<0> {
    virtual void pray() override {std::cout << "Prays like a Protestant.\n";}
};

template <> class Denomination<2> : public Religion {
    virtual void pray() override {std::cout << "Prays like a Muslim.\n";}
};

template <> class Denomination<2,0> : public Denomination<2> {
    virtual void pray() override {std::cout << "Prays like a Sunni Muslim.\n";}
};

template <> class Denomination<2,0,1> : public Denomination<2,5> {
    virtual void pray() override {std::cout << "Prays like a Hanafi Sunni Muslim.\n";}
};

template <int...> struct ReligionDatabase;

template <> struct ReligionDatabase<> {
    static const std::vector<Religion*> denominations;
};
const std::vector<Religion*> ReligionDatabase<>::denominations = {new Denomination<0>, new Denomination<1>, new Denomination<2>};

template <> struct ReligionDatabase<0> {
    static const std::vector<Religion*> denominations;
};
const std::vector<Religion*> ReligionDatabase<0>::denominations = {new Denomination<0,0>, new Denomination<0,1>};

template <> struct ReligionDatabase<2> {
    static const std::vector<Religion*> denominations;
};
const std::vector<Religion*> ReligionDatabase<2>::denominations = {new Denomination<2,0>, new Denomination<2,1>, new Denomination<2,2>};

template <> struct ReligionDatabase<2,0> {
    static const std::vector<Religion*> denominations;
};
const std::vector<Religion*> ReligionDatabase<2,0>::denominations = {new Denomination<2,0,0>, new Denomination<2,0,1>, new Denomination<2,0,2>};

template <int...> struct D {};
template <typename Output, int... Input> struct RemoveLastHelper;

template <int... Accumulated, int First, int... Rest>
struct RemoveLastHelper<D<Accumulated...>, First, Rest...> : RemoveLastHelper<D<Accumulated..., First>, Rest...> {};

template <int... Accumulated, int Last>
struct RemoveLastHelper<D<Accumulated...>, Last> : std::integral_constant<int, Last> {
    using type = D<Accumulated...>;
};

template <int... Is>
using RemoveLast = RemoveLastHelper<D<>, Is...>;

class Person {
    template <typename> struct GetReligion;
    Religion* religion;
public:
    template <int... Is> Person (const D<Is...>&) : Person(RemoveLast<Is...>{}) {}
    template <typename T> Person (const T&) : religion(GetReligion<typename T::type>::get(T::value)) {}
    void pray() {religion->pray();}
};

template <int... Is>
struct Person::GetReligion<D<Is...>> {
    static Religion* get(int n) {return ReligionDatabase<Is...>::denominations[n];}
};

int main() {
    Person* person1 = new Person(D<2,0,1>{});  // "Prays like a Hanafi Sunni Muslim."
    Person* person2 = new Person(D<2,0>{});  // "Prays like a Sunni Muslim."
    Person* person3 = new Person(D<2>{});  // "Prays like a Muslim."
    person1->pray();
    person2->pray();
    person3->pray();

//  Person* person4 = new Person(D<2,0,1,2,1,3>{});  // This doesn't compile.
//  person4->pray();  // Should be "Prays like a Hanafi Sunni Muslim."

    Person* person5 = new Person(D<0>{});
    Person* person6 = new Person(D<0,1>{});
    person5->pray();  // "Prays like a Christian."
    person6->pray();  // "Prays like a Protestant."
}

I still need help to get person4 to compile though. I need the compiler to somehow reduce the Denomination<2,0,1,2,1,3> to Denomination<2,0,1>. How to get that done?