Mechanism for extensible conditional statement

Question

I have these lines in my code:

//lines in mycode.c++
  QString str = "...some id...";

       if( str == "int")
           foo< int>()
  else if( str == "QString")
           foo< QString>()
       ...

I need to create a mechanism to include custom types in this conditional statement. So, any programmer can register his class and his implementation of foo templated function.

I imagine it like this:

//A.h -- custom class
class A { };

template< >
  void foo< A>() { ... };

DECL( A, "A"); //macro to declare class

I want conditional statement in mycode.c++ that would automatically take in account declaration of class A, so it will have additional lines:

else if( str == "A")
    foo< A>()

I could have this effect like this:

//common.h
  void process_id( QString str) {
       if( str == "int")
           foo< int>()
  else if( str == "QString")
           foo< QString>()
       ...
  else if( str == "A") //this lines programmer put manually
           foo< A>();
  }

//mycode.c++
  #include "common.h"

  QString str = "some_id";

  process_id( str);

but what if programmer forgets to edit common.h file?

I thought, maybe to use C-macros system, or somehow Qt-precompilation. Is it possible?

Sure it is possible. However you need to be aware that at some point the programmer will have to give a list of possible strings and their result, so you will still have pretty much the same problem (although the syntax may be a tiny bit nicer). — danielschemmel, Jan 29 '15 at 15:35
Did you consider using a factory/map to dispatch the calls rather than `if/else`? — Mark B, Jan 29 '15 at 15:36
This feels all backwards to be. Why use a giant `if` block when you can use dispatch? — John Dibling, Jan 29 '15 at 15:39
@MarkB In my mycode.c++ I need to call function with template parameter decided from runtime variable. If I can do this without if/else -- that's ok. — Valentin T., Jan 29 '15 at 15:39
For example, your datatypes should be able to `foo` themselves, rahter than having to explicitly call a different `foo` for a specific datatype. — John Dibling, Jan 29 '15 at 15:43
@JohnDibling I believe this want work for me. I serialize objects to strings and put them in DB. After I go back-process making deserialization. And at this moment I don't know what concrete type I put there. So I use ids to mark this strings and map them in runtime to generate proper class. This lines with *if* is from deserialization. — Valentin T., Jan 29 '15 at 15:49
So `foo` is a factory function? Then store numeric identifiers instead of strings, and implement a jump table (similar to @Barry's solution below). — John Dibling, Jan 29 '15 at 15:52

score 3 · Answer 1 · answered Jan 29 '15 at 15:36

I would just create a vector of functors:

using ProcessFunc = std::function<bool(const QString&)>;
std::vector<ProcessFunc> ids;

void process_id(QString str) {
    for (ProcessFunc& f : ids) {
        if (f(str)) {
            break;
        }
    }

    // or...
    std::any_of(ids.begin(), ids.end(), [&](const ProcessFunc& f){
        return f(str);
    });
}

Where you just provide a method to append a new such ProcessFunc:

template <typename T>
void register_class(const QString& name) {
    ids.emplace_back([=](const QString& str) {
        if (str == name) {
            foo<T>();
            return true;
        }
        else {
            return false;
        }
    });
}

Your example specifically would be:

register_class<int>("int");
register_class<QString>("QString");
register_class<A>("A");

Which I suppose you could turn into a macro if you really wanted to.

@ValentinT. It needs to be accessible to wherever `process_id` lives. If that's a class, then a private member would make the most sense. — Barry, Jan 29 '15 at 16:12

Nawaz · Accepted Answer · 2015-01-29T16:21:26.123

3

I would do something like this:

void process_id(QString const & str) 
{
   auto it =  g_actions.find(str);
   if ( it != g_actions.end() )  
         (it->second)(); //invoke action
}

And the framework to support the above is implemented as:

 using action_t = std::function<void()>;

 std::map<QString, action_t>  g_actions; //map of actions!

#define VAR_NAME(x)       _ ## x
#define DEFINE_VAR(x)  VAR_NAME(x)
#define REGISTER(type) char DEFINE_VAR(__LINE__) = (g_actions[#type] = &foo<type>,0)

Now you could register any class as:

 //these lines can be at namespace level as well!
 REGISTER(A);
 REGISTER(B);
 REGISTER(C);

And then call process_id() as:

process_id("A"); //invoke foo<A>();
process_id("B"); //invoke foo<B>();

Hope that helps.

See this online demo.

edited Jan 29 '15 at 16:21

answered Jan 29 '15 at 15:54

Nawaz

353,942
115
666
851

I think **&foo** must be **&foo**. Should I make *g_actions* extern, or somethink like this? – Valentin T. Jan 29 '15 at 16:10
@ValentinT.: Yes. That's correct. Edited it, adding an online demo. – Nawaz Jan 29 '15 at 16:22
Thanks, I see that this works for C++11. Now trying to recreate it for 4.9.2 ( http://ideone.com/lG0sn1 ). – Valentin T. Jan 29 '15 at 16:28
You need to use `DEFINE_VAR(__LINE__)` instead of `char _ ##__LINE__`. – Nawaz Jan 29 '15 at 16:30
Also `typedef void action_t( void);` defines a function-type, **not** a function-pointer type. Use `typedef void (*action_t)(void);` – Nawaz Jan 29 '15 at 16:32

Mechanism for extensible conditional statement

2 Answers2