How to avoid type comparision using polymorphism

[dancas2]

Hi everybody!


I'm facing a new problem while developing an application and I'd like to hear some advices regarding its design.

I have a class (ObjectAction) which defines what should be done on specific situations. As I want to have different kinds of those "actions", I was thinking to define ObjectAction like this:

class ObjectAction {
public:
   virtual void perform(...) = 0;
   virtual void writeToFile() = 0:
   virtual void readFromFile(...) = 0;
};

class ObjectAction {
public:
   virtual void perform(...) = 0;
   virtual void writeToFile() = 0:
   virtual void readFromFile(...) = 0;
};

To copy to clipboard, switch view to plain text mode 

So I can define its behavior by subclassing ObjectAction. For example:

class ExampleAction : public ObjectAction {
public:
     QString getData() const { return data; }
     void setData(const QString& newData)  { data = newData; }
     void perform(...) {
          qDebug() << data;
     }
     // Other definitions missing
     .......
private:
    QString data;
}; 
 
class OtherAction : public ObjectAction {
public:
   ......
   void perform() { /*something else */ }
   .....
private:
   QHash<QString, int> data;
};

class ExampleAction : public ObjectAction {
public:
     QString getData() const { return data; }
     void setData(const QString& newData)  { data = newData; }
     void perform(...) {
          qDebug() << data;
     }
     // Other definitions missing
     .......
private:
    QString data;
}; 

class OtherAction : public ObjectAction {
public:
   ......
   void perform() { /*something else */ }
   .....
private:
   QHash<QString, int> data;
};

To copy to clipboard, switch view to plain text mode 

It seems to be the good choice, but there is a problem: I want to provide an editor which allows user to set the ObjectAction to use, and he should be able to change the action kind and its data, so in my editor, if the action is of type ExampleAction, I will show a QLineEdit with the current data, but if the action is of type OtherAction, I should show some other widget to allow modifying the QHash. The same thing applies when I need to construct the action from data read from a file. The question is: How should I determine the type? Or better, how should I draw the editor for each type?

Thank you very much!

[stampede]

if the action is of type ExampleAction, I will show a QLineEdit with the current data, but if the action is of type OtherAction, I should show some other widget to allow modifying the QHash

You can add pure virtual method to ObjectAction class, and return different editor for each class:

class ObjectAction {
public:
   virtual void perform(...) = 0;
   virtual void writeToFile() = 0:
   virtual void readFromFile(...) = 0;
   virtual QWidget * createEditor() = 0;
};
 
...
 
class ExampleAction : public ObjectAction {
 
public:
 
     QString getData() const { return data; }
     void setData(const QString& newData)  { data = newData; }
     void perform(...) {
          qDebug() << data;
     }
     QWidget * createEditor(){
         return new StringEditor(...);
     }
 
     // Other definitions missing
     .......
 
private:
    QString data;
 
}; 
 
 
 
class OtherAction : public ObjectAction {
public:
   ......
   void perform() { /*something else */ }
   QWidget * createEditor(){
      return new HashEditor(...);
   }
   .....
private:
   QHash<QString, int> data;
 
};

class ObjectAction {
public:
   virtual void perform(...) = 0;
   virtual void writeToFile() = 0:
   virtual void readFromFile(...) = 0;
   virtual QWidget * createEditor() = 0;
};

...

class ExampleAction : public ObjectAction {

public:

     QString getData() const { return data; }
     void setData(const QString& newData)  { data = newData; }
     void perform(...) {
          qDebug() << data;
     }
     QWidget * createEditor(){
         return new StringEditor(...);
     }

     // Other definitions missing
     .......

private:
    QString data;

}; 

 

class OtherAction : public ObjectAction {
public:
   ......
   void perform() { /*something else */ }
   QWidget * createEditor(){
      return new HashEditor(...);
   }
   .....
private:
   QHash<QString, int> data;

};

To copy to clipboard, switch view to plain text mode 

HashEditor and StringEditor can be both subclasses of QWidget, or a custom QWidget-based AbstractEditor type etc.

[dancas2]

Hi stampede, thanks for your reply!

I had already considered that approach, but there are two reasons I don’t like it:

1. It polutes the class declaration, because the editor is only needed in a separate application that allows user to manage the “actions” of some objects and then it’s saved to a file. In the main application I just need to read that file and “perform” them
2. I would anyway need to figure the current action type in order to provide a QComboBox with action types and setting the current type there

Thank you very much!

[stampede]

I agree.
You want to avoid type comparison, but you can't complete this without actually comparing something.
So another way. You can see how, for example, QEvent and its subclasses are implemented - there is a type enumeration for each subclass in QEvent class, then its possible to distinguish between the subtypes, using this enumeration. So for your case:

class ObjectAction {
public:
   enum Type{
      Example,
      Other,
      ....
   }
   virtual Type type() const = 0;
   ...
};
 
...
 
class ExampleAction : public ObjectAction {
public:
 
     Type type() const{
          return Example;
     }
...
private:
    QString data;
 
}; 
 
class OtherAction : public ObjectAction {
 
public:
 
   Type type() const{
        return Other;
   }
   .....
private:
   QHash<QString, int> data;
 
};

class ObjectAction {
public:
   enum Type{
      Example,
      Other,
      ....
   }
   virtual Type type() const = 0;
   ...
};

...

class ExampleAction : public ObjectAction {
public:

     Type type() const{
          return Example;
     }
...
private:
    QString data;

}; 

class OtherAction : public ObjectAction {

public:

   Type type() const{
        return Other;
   }
   .....
private:
   QHash<QString, int> data;

};

To copy to clipboard, switch view to plain text mode 

etc. (actually, its slightly different in QEvent, to allow user-defined events, but its not important right now)
Then you can implement ActionEditors without modifying the Action impl.:

#include "ObjectAction.h"
 
class ActionEditorCreator{
    QWidget * createEditor( ObjectAction * action ){
        switch(action->type()){
            case ObjectAction::Example :
               return new StringEditor(action);
            case ObjectAction::Other :
               return new HashEditor(action); 
        }
    }
};

#include "ObjectAction.h"

class ActionEditorCreator{
    QWidget * createEditor( ObjectAction * action ){
        switch(action->type()){
            case ObjectAction::Example :
               return new StringEditor(action);
            case ObjectAction::Other :
               return new HashEditor(action); 
        }
    }
};

To copy to clipboard, switch view to plain text mode 

Does it suits your needs better ? It solves 1) I guess.
As for 2), what do you mean by " QComboBox with action types and setting the current type there", maybe I don't see the whole picture.

[dancas2]

Hi stampede, thanks again for your reply!

Really I don't care if I have to compare a type (because I need it anyway), I just want to make it easy to add new action types later, without having to check those types in many places.

Previously I had implemented something like your suggestion, but I was checking the type to decide what to perform, so I had to check the type not only in editor and action creation but in action "processor" too. Of course, by that way I had to store the data in a QVariant (or maybe a C++11 union, but that's not implemented in my compiler now), so I was wasting memory and I had to cast the data everytime I wanted to process the action.

By this way there would be only two places where I have to check the type, so I think it is ok for me.

As for 2), let me explain my situation a bit better. Some classes of my application have a QVector<ObjectAction*>, which defines what will do that class and the order they will do that. The editor just shows a list of the available actions and let you add some of them to some class (with the data needed for that action). But the user should be able to modify one action (including its type) if he wants, it wouldn't be good if he had to recreate the whole class or the whole actions just to change the type of one action!. So in my editor, there is a combo box with every action type, and the user choose the one he will use. Of course, if he changes the type, all the data of that action is lost, but there is no problem with it!.

Anyway, there is a problem with your suggestion: resource handling. As the editor will be shown each time the user selects an "action", I would have to delete the old editor and create the new one. In my old design I had a QStackedWidget and just changed the page when the type changed (as the type is numeric). I would have to check the type to generate a new Action from UI, but I think I have no choice, right?

Thank you very much!

[stampede]

I would have to delete the old editor and create the new one

Not necessary, you can create one editor for each action type, and just pass it different "action" instances to display and modify. Every object of given "Action" type will be modified the same way, only the data will change.
For example, lets say you want to display different text in line edit placed on your widget. Probably you will only pass another QString instance into line edit, not delete old and create new line edit object.

[dancas2]

Not directly with the previous code, I think:

class ActionEditorCreator{
QWidget * createEditor( ObjectAction * action ){
switch(action->type()){
case ObjectAction::Example :
return new StringEditor(action);
case ObjectAction::Other :
return new HashEditor(action);
}
}
};

class ActionEditorCreator{
QWidget * createEditor( ObjectAction * action ){
switch(action->type()){
case ObjectAction::Example :
return new StringEditor(action);
case ObjectAction::Other :
return new HashEditor(action);
}
}
};

To copy to clipboard, switch view to plain text mode 

Anyway, don't worry. It's not that hard to solve.

Thank you very much!

[stampede]

Not directly with the previous code

Sure, the code was just to present the previous idea

[amleto]

This is where a factory would normally come in. You register the type/type-id with a function that creates the correct editor.

so then the comparison is pushed deeper (e.g. into a map inside the factory), and you don't need to modify the factory for every new object (open/closed principle).