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

Это очень похоже на архитектуру плагина. Я рекомендую начать с (неофициальной) диаграммы потока данных, чтобы определить:

• как эти блоки обрабатывают данные
• какие данные нужно передать
• какие результаты возвращаются из одного блока в другой (данные/коды ошибок/исключения)

С помощью этой информации вы можете начать создавать общие интерфейсы, которые позволяют выполнять привязку к другим интерфейсам во время выполнения. Затем я бы добавил фабричную функцию к каждому модулю, чтобы запросить из него реальный объект обработки. Я не рекомендую получать объекты обработки напрямую из интерфейса модуля, а возвращать фабричный объект, из которого можно получить объекты обработки. Затем эти объекты обработки используются для построения всей цепочки обработки.

Упрощенно схема будет выглядеть так:

struct Processor
{
    void doSomething(Data);
};

struct Module
{
    string name();
    Processor* getProcessor(WhichDoIWant);
    deleteprocessor(Processor*);
};

В моем уме, вероятно, появятся эти шаблоны:

• фабричная функция: получать объекты из модулей
• композитный && декоратор: формирование цепочки обработки

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

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

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

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

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

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

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

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

Недостатком метода 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;
}