Templated factory based on the union of different enum class values

Question

I'm trying to create a kind of Factory based on some enum values that the user can choose a compile time.

The main thing here is to create a kind of magic switch that works on different values of more than one kind of enum (kind of union of different union values, possibly with same value).

enum class A  {A1, A2, A3, A4};
enum class B  {B1, B2, B3, B4, B6, B7};

struct ObjectBase 
{
virtual void apply(char input) = 0;
};

template<A a, class... Args>
struct Object : ObjectBase;

template<>
struct Object<A::A1, int> : ObjectBase
{
Object(int i) i_(i) { }
void apply(char input) { /*do stuff with i_*/}
int i_;
}

template<>
struct Object<A::A2, int, double> : ObjectBase
{
Object(int i, double d) i_(i), d_(d) { }
void apply(char input) { /*do stuff with i_*/}
int i_;
double d_;
}


template<class V, V value>
struct Element 
{
};

template<class V, V first, V last>
struct AllElementWithin 
{
};

Switcher< Element<A,A1>, Element<A,A2>, 
  AllElementWithin<B, B1, B3> > switcher (2, 4.0);
// This should create a switch / lookup table that 
// initializes for instance Object<A::A1> with 2
// and Object<A::A2> with 2 and 4

char myInput = 'F';
ObjectBase* ob = switcher.create(A::A1); 
// This should return an ObjectBase* that points to a 
// Object<A1,int>

ob->apply(myInput);

Is there an already kwown implementation pattern I can exploit here? I wouldn't like to re-invent the wheel.

Best would be something that compiles with C++11

[Edit] Some more info:

The factory should allow the creation of objects of different kind (that inherit from a specific base) in an efficient way. Ideally the user class that wants to add more objects can just create his enum and some classes that define the wanted behavior, and simply use the factory with these enums together with some other enums defined by other people.

Please ask for other clarifications if it's not clear

I somehow have the feeling that [`std::variant`](https://en.cppreference.com/w/cpp/utility/variant) could be worth a look. — Scheff's Cat, Nov 12 '18 at 10:10
Maybe you should clarify the question a bit - perhaps renaming classes, etc. to the intent. It is not really clear if this is an Abstract Factory or Concrete Factory pattern you aim at. Judging from the code you show and your naming it looks more like a Concrete Factory. — darune, Nov 12 '18 at 10:12
@Scheff I thought about using it too, to replace the virtual method. I'd do that optionally. — svoltron, Nov 12 '18 at 10:15
@darune yes, probably I'd better to clarify something. I'll edit the question — svoltron, Nov 12 '18 at 10:15
What would you do with `template<> struct Object : ObjectBase` (note the incompatible type)? — Aconcagua, Nov 12 '18 at 10:20
@Aconcagua in which way incompatible? it seems to me that's not so different compared to the other cases — svoltron, Nov 12 '18 at 10:28
@svoltron I assume the `void*` variant would accept a `void*` pointer in the constructor, too. To avoid solving the isssue via cast, assume a data type that int cannot be cast to (e. g. `std::string`). How would you want to construct it from arguments `2, 4.0` you provide to the constructor of your switcher? — Aconcagua, Nov 12 '18 at 10:33
@Aconcagua ok I've understood your question now. If you have another input, you of course, have to pass it in switcher. Automatically, maybe using a traits that specifies what kind of input take, or the position of the input in a tuple perhaps, it would take the correct value. — svoltron, Nov 12 '18 at 10:44
How would you handle a class with more than one constructor? — Aconcagua, Nov 12 '18 at 12:08
Have you tried do to something really simple like `std::vector< std::variant > switch_type_one = {A::A1, A::A2, B::B1};` ? perhaps with some clever typing it could perhaps even be expanded to a map for looking up the construction parameters (although im not really sure how difficult that would be). What would be wrong with that type of solution ? — darune, Nov 12 '18 at 12:17
@Aconcagua with some kind of traits perhaps or just assuming only one constructor must be provided — svoltron, Nov 12 '18 at 13:35
@darune problem is that if there are N > 100, 200 types, one of them for sure would be very very big, and I don't want to pay that price for all the elements — svoltron, Nov 12 '18 at 13:36

score 2 · Accepted Answer · answered Nov 12 '18 at 13:17

Something like this might suit your needs (using void* for not having to introduce a base class, leaving adjustment to you...):

template <typename T, typename SelType, SelType SelValue, typename ... Arguments>
class Creator
{
    std::tuple<Arguments...> arguments;

    template<size_t ... Indices>
    void* create(std::index_sequence<Indices...>)
    {
        return new T( (std::get<Indices>(arguments), ...) );
    }

public:
    Creator(Arguments ... arguments)
        : arguments(arguments...)
    { }

    using SelectorType = SelType;
    static SelType const selectorValue = SelValue;
    void* create()
    {
        return create(std::index_sequence_for<Arguments...>{});
    }
};

template<typename ... Creators>
class Switcher
{
    std::tuple<Creators ...> creators;

    template<typename T, size_t Index>//, typename First, typename ... Remaining>
    void* select(T selector)
    {
        if constexpr(Index < sizeof...(Creators))
        {
            if constexpr(std::is_same<T, typename std::tuple_element<Index, decltype(creators)>::type::SelectorType>::value)
            {
                if(selector == std::tuple_element<Index, decltype(creators)>::type::selectorValue)
                    return std::get<Index>(creators).create();
            }
            return select<T, Index + 1>(selector);
        }
        return nullptr;
    }

public:
    Switcher(Creators ... creators)
            : creators(creators...)
    { }

    template <typename T>
    void* create(T t)
    {
        return select<T, 0U>(t);
    }
};

Usage:

Switcher switcher
(
        Creator<std::string, A, A::A1, char const*>("hello"),
        Creator<double, A, A::A2, double>(10.12),
        Creator<uint32_t, B, B::B1, unsigned int>(7U)
);

// just for demonstration purposes: don't care for the memory leaks...
std::cout << *(std::string*)switcher.create(A::A1) << std::endl;
std::cout << *(double*)switcher.create(A::A2) << std::endl;
std::cout << *(uint32_t*)switcher.create(B::B1) << std::endl;

On my machine, printed happily:

hello
10.12
7

yep, that seems a cool solution. I was looking for something in C++11, but at least this is an idea that works :) — svoltron, Nov 12 '18 at 13:32
I've just noticed that this solution however does not fit exactly what I was looking for. Basically I would need something like Switcher switcher(myInputs); switcher(A::A1); switcher(A::A2); so, just one declaration that works for all the enums — svoltron, Nov 12 '18 at 13:40
@svoltron It works for *any* arbitrary number of enums - note the `B::B1` being included in the demo; whichever enums you want to use, all is configured via the creator instantiations you provide as template arguments to the switcher... — Aconcagua, Nov 12 '18 at 13:57
@svoltron I think the index sequence is the only C++14 feature I used. You might rebuild it yourself, there's more than one single answer for, e. g. [this one](https://stackoverflow.com/a/7858971/1312382). [Similar](https://stackoverflow.com/a/49672613/1312382), going a bit more into details. — Aconcagua, Nov 12 '18 at 14:05
Yep, that's true, it works for any enum, my oversight. This solution works very well I think, it's only the basic usage I'm not totally ok with. What I meant was just to use a Switcher switcher(inputs); without defining anything else if possible, but I guess it's too much hehe. The index sequence it's ok, it's the C++17 constexpr if that I "don't like" — svoltron, Nov 12 '18 at 14:18
@svoltron If you don't like the `if constexpr`, make an ordinary `if` from. I used it mainly for *assuring* that the if is resolved at compile time - but as the expression is constant anyway, chances are that the compiler will do so even without `constexpr`... — Aconcagua, Nov 12 '18 at 17:12

Templated factory based on the union of different enum class values

1 Answers1