Meta programming with singleton

Question

I'd like to choose between two different code paths depending on the value of an enum for a singleton class. Singleton classes inherit from a "CSingleton" type, where T is the type of the new class.

enum class Paths
{
    PATH_ONE = 0,
    PATH_TWO,    
}

template<Paths pathValue>
class Foo : public CSingleton<Foo>
{
public:
    Foo()
    {
        if(pathValue == Paths::PATH_ONE)
             myValue = 11;
        else if(pathValue == Paths::PATH_TWO)
             myValue = 22;
    }

    int myValue;

};

Then when using an object I could do something like this:

assert(11 == Foo<Paths::PATH_ONE>::Instance().myValue);

To be explicit, Instance() is what will create the object.

Does what I'm trying to do have a name? Is there a part of Boost or C++11 that can help me out?

Thanks!

Answer 1

You are effectively trying to take a runtime decision and make it at compile time. For this simple example, you can do it simply by casting the enumeration value to an int

myValue = static_cast<int>(pathValue);

But the better approach would probably be to create a constructor that takes a parameter:

Foo(const Paths& path)
{
    if(path == Paths::PATH_ONE)
    {
         // do something
    }
    else if(path == Paths::PATH_TWO)
    {
         // do something else
    }
}

In which case, your class no longer needs to be a template:

class Foo : public SomeParent { ... };

Another solution would be to specialize the template for the values, but you would need 2 class declarations for that.

Answer 2

One usual metaprogramming way to solve such problems (independently of having a singleton class or not!) goes as follows:

enum Selections
{
    PATH_ONE ,
    PATH_TWO ,
};

class ImplBase : public ImplBase
{
    // Declare an interface and common implementation bits
}

class ImplBaseOne : public ImplBase
{
    // Implement details for PATH_ONE
};

class ImplBaseTwo
{
    // Implement details for PATH_TWO
};

---

template<Selections Choice>
struct Selector
{
     typedef void Result; // This should result in a compiler error for 
                          // invalid/unknown specializations
};

template<>
struct Selector<PATH_ONE>
{
     typedef ImplBaseOne Result;
};

template<>
struct Selector<PATH_ONE>
{
     typedef ImplBaseOne Result;
};

template<>
struct Selector<PATH_TWO>
{
     typedef ImplBaseTwo Result;
};

---

template<Selections Choice>
class ExposedClass : public Selector<Choice>::Result
{
    // ...
}

Answer 3

You have several way to do what you want at compile time which turn into template specialization:

1. Just for values

template<Paths> struct MyValue;

template<> struct MyValue<Paths::PATH_ONE> { static constexpr int value = 11; };
template<> struct MyValue<Paths::PATH_TWO> { static constexpr int value = 22; };

And so you have:

Foo() { myValue = MyValue<pathValue>::value; }

2. For functions

You may create several functions/method parametrized

template<Paths> void MyAssignVariable(int& var);

template<> void MyAssignVariable<Paths::PATH_ONE>(int& var) { var = 11; };
template<> void MyAssignVariable<Paths::PATH_TWO>(int& var) { var = 22; };

And so you have:

Foo() { MyAssignVariable<pathValue>(myValue); }

And as partial specialization is not possible on function, the following is preferred:

template<Paths> struct PathSpecialization;

template<> struct PathSpecialization<Paths::PATH_ONE> {
    static void MyAssignVariable(int& variable) { variable = 11; };
    // You may add other methods here.
};
template<> struct PathSpecialization<Paths::PATH_TWO> {
    static void MyAssignVariable(int& variable) { variable = 22; };
    // You may add other methods here.
};

And so you have:

Foo() { PathSpecialization<pathValue>::MyAssignVariable(myValue); }