ich suche nach einem geeigneten Pattern für folgendes Problem:

class Task
{
public:
  void execute();
  void cancel() { canceling = true;}; 
  void setCallback(TaskCallback* callback); //setter

private:
 std::list<SubTask> subTasks;
 bool canceling = false; 
 TaskCallback* callback; 
};

void Task::execute()
{
   for(subTask : subTasks)
   {
      if(canceling)
      {
        if(callback)
          callback->onCancel(); 

        return;
      }
      subTask->execute(); 
   }

   if(callback)
      callback->onDone(); 
}

Wenn Task::execute aufgerufen wird, werden die zu diesem Task dazugehörigen SubTasks nacheinander ausgeführt. Nach jedem SubTask soll der Task gecancelt werden können. Jeder SubTask liefert als Output ein Ergebnis zurück, dass vom nächsten SubTask als Input verwendet werden soll. Wie moduliert man das am sinnvollsten?

Ich möchte dies gern allgemein modulieren, so dass im Objekt Task alle möglichen Aufgaben abgearbeitet werden können. Gibt es hierfür irgendwelche Designpattern?

Gruß
patrick

ich suche nach einem geeigneten Pattern für folgendes Problem:

Ist das nicht schon fast die Lösung? Was genau ist das Problem?

patrick_hauser schrieb:

Jeder SubTask liefert als Output ein Ergebnis zurück, dass vom nächsten SubTask als Input verwendet werden soll. Wie moduliert man das am sinnvollsten?

Ungefähr so?

void Task::execute()
{
	boost::optional<Ergebnis> lastResult;
   for(subTask : subTasks)
   {
      if(canceling)
      {
        if(callback)
          callback->onCancel();

        return;
      }
      lastResult = subTask->execute(lastResult);
   }

   if(callback)
      callback->onDone();
}