#include <mutex>
#include <fstream>
#include "mermaid.h"
#include "util.h"
#include "portable.h"
#include "config.h"
#include "doxygen.h"
#include "message.h"
#include "debug.h"
#include "dir.h"
#include "indexlist.h"
#include "threadpool.h"

Include dependency graph for mermaid.cpp:

Functions
static void	runMermaid (const MermaidManager::DiagramList &diagrams)

Variables
static std::mutex	g_mermaidMutex
static int	g_mermaidIndex = 1

Function Documentation

◆ runMermaid()

void runMermaid ( const MermaidManager::DiagramList & diagrams )

static

Definition at line 131 of file mermaid.cpp.

{
  //printf("runMermaidContent for %zu images\n",contentList.size());
  if (diagrams.empty()) return;
 
  QCString mmdc = Config_getString(MERMAID_PATH);
  if (!mmdc.isEmpty() && mmdc.at(mmdc.length()-1) != '/' && mmdc.at(mmdc.length()-1) != '\\')
  {
    mmdc += "/";
  }
  mmdc += "mmdc";
 
  QCString mermaidConfigFile = Config_getString(MERMAID_CONFIG_FILE);
 
  struct MermaidCmd
  {
    MermaidCmd(const QCString &mmdc_,const QCString &args_,const QCString &ext_,const QCString &srcFile_,int srcLine_) :
      mmdc(mmdc_), args(args_), ext(ext_), srcFile(srcFile_), srcLine(srcLine_) {}
    QCString mmdc;
    QCString args;
    QCString ext;
    QCString srcFile;
    int srcLine;
  };
  std::vector<MermaidCmd> mermaidCmds;
 
  for (const auto &diagram : diagrams)
  {
    //printf("content=%s\n",qPrint(mc.content));
    if (diagram.info.content.isEmpty()) continue;
 
    QCString ext = MermaidManager::imageExtension(diagram.imageFormat);
 
    QCString inputFile  = diagram.info.baseName + ".mmd";
    QCString outputFile = diagram.info.baseName + "." + ext;
 
    // Check if content has changed since last run (caching)
    FileInfo fi(outputFile.str());
    if (fi.exists())
    {
      QCString cachedContent = fileToString(inputFile);
      if (cachedContent == diagram.info.content)
      {
        continue;
      }
    }
 
    // Build the mmdc command arguments
    QCString args;
    args += "-q -i \"" + inputFile + "\" ";
    args += "-o \"" + outputFile + "\" ";
 
    if (!mermaidConfigFile.isEmpty())
    {
      args += "-c \"" + mermaidConfigFile + "\" ";
    }
 
    mermaidCmds.emplace_back(mmdc, args,ext, diagram.info.srcFile, diagram.info.srcLine);
  }
 
  std::size_t numThreads = static_cast<std::size_t>(Config_getInt(DOT_NUM_THREADS));
  size_t offset=0;
  size_t total=mermaidCmds.size();
  msg("Generating {} Mermaid files using {} threads\n", total, numThreads);
  if (numThreads>1) // multi threaded version
  {
    ThreadPool threadPool(numThreads);
    std::vector< std::future<int> > results;
 
    // queue the work
    for (const auto &cmd : mermaidCmds)
    {
      auto processFile = [&cmd]()
      {
        Debug::print(Debug::Mermaid, 0, "*** MermaidManager::run Running: {} {}\n", cmd.mmdc, cmd.args);
        int exitCode = Portable::system(cmd.mmdc.data(), cmd.args.data(), TRUE);
        if (exitCode != 0)
        {
          err_full(cmd.srcFile, cmd.srcLine,
              "Problems running Mermaid (mmdc). Verify that the command '{} {}' works from the command line. Exit code: {}.",
              cmd.mmdc, cmd.args, exitCode);
        }
        return exitCode;
      };
      results.emplace_back(threadPool.queue(processFile));
    }
 
    // wait for the results
    for (auto &f : results)
    {
      offset++;
      msg("Generating Mermaid file {}/{}\n", offset, total);
      f.get();
    }
  }
  else // single threaded version
  {
    for (const auto &cmd : mermaidCmds)
    {
      offset++;
      msg("Generating Mermaid file {}/{}\n", offset, total);
      Debug::print(Debug::Mermaid, 0, "*** MermaidManager::run Running: {} {}\n", cmd.mmdc, cmd.args);
 
      int exitCode = Portable::system(cmd.mmdc.data(), cmd.args.data(), TRUE);
      if (exitCode != 0)
      {
        err_full(cmd.srcFile, cmd.srcLine,
            "Problems running Mermaid (mmdc). Verify that the command '{} {}' works from the command line. Exit code: {}.",
            cmd.mmdc, cmd.args, exitCode);
      }
    }
  }
}