Как записать гибкую модульную программу с хорошими возможностями взаимодействия между модулями?

Это действительно кажется довольно тривиальным, поэтому я полагаю, что мы упускаем некоторые требования.

Используйте Мемоизацию , чтобы не вычислять результат более одного раза. Это нужно делать в рамках.

Вы можете использовать некую блок-схему, чтобы определить, как передать информацию от одного модуля к другому ... но самый простой способ - заставить каждый модуль напрямую вызывать те, от которых они зависят. С мемоизацией это не требует больших затрат, поскольку, если она уже вычислена, все в порядке.

Поскольку у вас должна быть возможность запускать любой модуль, вам нужно дать им идентификаторы и где-нибудь зарегистрировать, чтобы можно было искать их во время выполнения. Есть два способа сделать это.

• Exemplar: Вы получаете уникальный экземпляр такого модуля и выполняете его.
• Factory: вы создаете модуль запрошенного типа, выполняете его и выбрасываете.

Обратной стороной метода Exemplar является то, что если вы выполните модуль дважды, вы начнете не из чистого состояния, а из состояния, в котором его оставило последнее (возможно, неудачное) выполнение. Для мемоизации это можно рассматривать как преимущество, но если это не удалось, результат не вычисляется (ура), поэтому я бы не рекомендовал это делать.

Так как ты ...?

Начнем с фабрики.

class Module;
class Result;

class Organizer
{
public:
  void AddModule(std::string id, const Module& module);
  void RemoveModule(const std::string& id);

  const Result* GetResult(const std::string& id) const;

private:
  typedef std::map< std::string, std::shared_ptr<const Module> > ModulesType;
  typedef std::map< std::string, std::shared_ptr<const Result> > ResultsType;

  ModulesType mModules;
  mutable ResultsType mResults; // Memoization
};

Это действительно очень простой интерфейс. Однако, поскольку нам нужен новый экземпляр модуля каждый раз, когда мы вызываем Organizer (чтобы избежать проблемы повторного входа), нам нужно будет поработать с нашим интерфейсом Module .

class Module
{
public:
  typedef std::auto_ptr<const Result> ResultPointer;

  virtual ~Module() {}               // it's a base class
  virtual Module* Clone() const = 0; // traditional cloning concept

  virtual ResultPointer Execute(const Organizer& organizer) = 0;
}; // class Module

А теперь это просто:

// Organizer implementation
const Result* Organizer::GetResult(const std::string& id)
{
  ResultsType::const_iterator res = mResults.find(id);

  // Memoized ?
  if (res != mResults.end()) return *(it->second);

  // Need to compute it
  // Look module up
  ModulesType::const_iterator mod = mModules.find(id);
  if (mod != mModules.end()) return 0;

  // Create a throw away clone
  std::auto_ptr<Module> module(it->second->Clone());

  // Compute
  std::shared_ptr<const Result> result(module->Execute(*this).release());
  if (!result.get()) return 0;

  // Store result as part of the Memoization thingy
  mResults[id] = result;

  return result.get();
}

И простой пример модуля / результата:

struct FooResult: Result { FooResult(int r): mResult(r) {} int mResult; };

struct FooModule: Module
{
  virtual FooModule* Clone() const { return new FooModule(*this); }

  virtual ResultPointer Execute(const Organizer& organizer)
  {
    // check that the file has the correct format
    if(!organizer.GetResult("CheckModule")) return ResultPointer();

    return ResultPointer(new FooResult(42));
  }
};

И из основного:

#include "project/organizer.h"
#include "project/foo.h"
#include "project/bar.h"


int main(int argc, char* argv[])
{
  Organizer org;

  org.AddModule("FooModule", FooModule());
  org.AddModule("BarModule", BarModule());

  for (int i = 1; i < argc; ++i)
  {
    const Result* result = org.GetResult(argv[i]);
    if (result) result->print();
    else std::cout << "Error while playing: " << argv[i] << "\n";
  }
  return 0;
}

Мне интересно, является ли C++ правильным уровнем, о котором стоит подумать для этой цели. По моему опыту, всегда было полезно иметь отдельные программы, которые соединяются вместе, в философии UNIX.

Если ваши данные не слишком велики, у разделения есть много преимуществ. Во-первых, вы получаете возможность тестировать каждую фазу обработки независимо, вы запускаете одну программу и перенаправляете вывод в файл: вы можете легко проверить результат. Затем, вы используете преимущества многоядерных систем, даже если каждая из ваших программ однопоточная, а значит, их гораздо легче создавать и отлаживать. И вы также используете преимущества синхронизации операционной системы, используя трубы между вашими программами. Может быть, некоторые из ваших программ могут быть выполнены с помощью уже существующих программ-утилит?

Ваша финальная программа создаст клей, чтобы собрать все ваши утилиты в одну программу, передавая данные из одной программы в другую (больше никаких файлов в это время) и реплицируя их по мере необходимости для всех ваших вычислений.