#include <mutex>
#include "plantuml.h"
#include "util.h"
#include "portable.h"
#include "config.h"
#include "doxygen.h"
#include "message.h"
#include "debug.h"
#include "fileinfo.h"
#include "dir.h"
#include "indexlist.h"
#include "stringutil.h"

Include dependency graph for plantuml.cpp:

Functions
static DString	javaExecutable ()
	Returns the java executable used to run the PlantUML jar file.
static void	runPlantumlContent (const PlantumlManager::FilesMap &plantumlFiles, const PlantumlManager::ContentMap &plantumlContent, PlantumlManager::OutputFormat format)
static void	print (const PlantumlManager::FilesMap &plantumlFiles)
static void	print (const PlantumlManager::ContentMap &plantumlContent)
static void	addPlantumlFiles (PlantumlManager::FilesMap &plantumlFiles, const std::string &key, const std::string &value)
static void	addPlantumlContent (PlantumlManager::ContentMap &plantumlContent, const std::string &key, const DString &outDir, const DString &puContent, const DString &srcFile, int srcLine)

Variables
static std::mutex	g_PlantUmlMutex

Function Documentation

◆ addPlantumlContent()

void addPlantumlContent	(	PlantumlManager::ContentMap &	plantumlContent,
		const std::string &	key,
		const DString &	outDir,
		const DString &	puContent,
		const DString &	srcFile,
		int	srcLine )

static

Definition at line 472 of file plantuml.cpp.

{
  auto kv = plantumlContent.find(key);
  if (kv==plantumlContent.end())
  {
    kv = plantumlContent.emplace(key,PlantumlContent("",outDir,srcFile,srcLine)).first;
  }
  kv->second.content+=puContent;
}

References addPlantumlContent(), and PlantumlContent::PlantumlContent().

Referenced by addPlantumlContent(), and PlantumlManager::insert().

◆ addPlantumlFiles()

void addPlantumlFiles	(	PlantumlManager::FilesMap &	plantumlFiles,
		const std::string &	key,
		const std::string &	value )

static

Definition at line 461 of file plantuml.cpp.

{
  auto kv = plantumlFiles.find(key);
  if (kv==plantumlFiles.end())
  {
    kv = plantumlFiles.emplace(key,StringVector()).first;
  }
  kv->second.push_back(value);
}

References addPlantumlFiles().

Referenced by addPlantumlFiles(), and PlantumlManager::insert().

◆ javaExecutable()

DString javaExecutable ( )

static

Returns the java executable used to run the PlantUML jar file.

Definition at line 247 of file plantuml.cpp.

{
  DString javaPath = Config_getString(PLANTUML_JAVA_PATH);
  if (!javaPath.empty()) return javaPath;
  DString javaHome = Portable::getenv("JAVA_HOME");
  if (!javaHome.empty())
  {
    DString javaHomeExe = javaHome+"/bin/java"+Portable::commandExtension();
    FileInfo fi(javaHomeExe.str());
    if (fi.exists() && fi.isFile()) return javaHomeExe;
  }
  return "java";
}

References Portable::commandExtension(), Config_getString, DString::empty(), FileInfo::exists(), Portable::getenv(), FileInfo::isFile(), javaExecutable(), and DString::str().

Referenced by javaExecutable(), and runPlantumlContent().

◆ print() [1/2]

void print ( const PlantumlManager::ContentMap & plantumlContent )

static

Definition at line 449 of file plantuml.cpp.

{
  if (Debug::isFlagSet(Debug::Plantuml))
  {
    for (const auto &[key,content] : plantumlContent)
    {
      Debug::print(Debug::Plantuml,0,"*** PlantumlManager::print Content PlantumlContent key: {}\n",key);
      Debug::print(Debug::Plantuml,0,"*** PlantumlManager::print Content:\n{}\n",content.content);
    }
  }
}

References Debug::isFlagSet(), Debug::Plantuml, Debug::print(), and print().

◆ print() [2/2]

void print ( const PlantumlManager::FilesMap & plantumlFiles )

static

Definition at line 434 of file plantuml.cpp.

{
  if (Debug::isFlagSet(Debug::Plantuml))
  {
    for (const auto &[key,list] : plantumlFiles)
    {
      Debug::print(Debug::Plantuml,0,"*** PlantumlManager::print Files PlantumlFiles key:{} size:{}\n",key,list.size());
      for (const auto &s : list)
      {
        Debug::print(Debug::Plantuml,0,"*** PlantumlManager::print                     list:{}\n",s);
      }
    }
  }
}

References Debug::isFlagSet(), Debug::Plantuml, Debug::print(), and print().

Referenced by PlantumlManager::insert(), print(), and print().

◆ runPlantumlContent()

void runPlantumlContent	(	const PlantumlManager::FilesMap &	plantumlFiles,
		const PlantumlManager::ContentMap &	plantumlContent,
		PlantumlManager::OutputFormat	format )

static

Definition at line 261 of file plantuml.cpp.

{
  /* example : running: java -Djava.awt.headless=true
               -jar "/usr/local/bin/plantuml.jar"
               -o "test_doxygen/DOXYGEN_OUTPUT/html"
               -tpng
               "test_doxygen/DOXYGEN_OUTPUT/html/A.pu"
               -charset UTF-8
               outDir:test_doxygen/DOXYGEN_OUTPUT/html
               test_doxygen/DOXYGEN_OUTPUT/html/A
   */
  int exitCode = 0;
  DString plantumlJarPath = Config_getString(PLANTUML_JAR_PATH);
  DString plantumlConfigFile = Config_getString(PLANTUML_CFG_FILE);
  DString plantumlTool = Config_getString(PLANTUML_TOOL);
  bool useJar = plantumlTool.empty(); // no PlantUML executable given, so run the jar file via java
 
  DString pumlExe = useJar ? javaExecutable() : plantumlTool;
  DString pumlArgs = "";
  DString pumlType = "";
  DString pumlOutDir = "";
 
  StringVector pumlIncludePathList = Config_getList(PLANTUML_INCLUDE_PATH);
  if (useJar)
  {
    auto it = pumlIncludePathList.begin();
    if (it!=pumlIncludePathList.end())
    {
      pumlArgs += "-Dplantuml.include.path=\"";
      pumlArgs += it->c_str();
      ++it;
    }
    while (it!=pumlIncludePathList.end())
    {
      pumlArgs += Portable::pathListSeparator();
      pumlArgs += it->c_str();
      ++it;
    }
    if (!pumlIncludePathList.empty()) pumlArgs += "\" ";
    pumlArgs += "-Djava.awt.headless=true -jar \""+plantumlJarPath+"\" ";
  }
  else if (!pumlIncludePathList.empty())
  {
    // a PlantUML executable does not take java system properties, but PlantUML also
    // accepts the include path via the environment.
    DString includePath;
    bool first = true;
    for (const auto &path : pumlIncludePathList)
    {
      if (!first) includePath += Portable::pathListSeparator();
      includePath += path.c_str();
      first = false;
    }
    Portable::setenv("PLANTUML_INCLUDE_PATH",includePath);
  }
  if (!plantumlConfigFile.empty())
  {
    pumlArgs += "-config \"";
    pumlArgs += plantumlConfigFile;
    pumlArgs += "\" ";
  }
  // the -graphvizdot option expects a relative or absolute path to the dot executable, so
  // we need to use the unverified DOT_PATH option and check if it points to an existing file.
  DString dotPath = Config_getString(DOT_PATH);
  FileInfo dp(dotPath.str());
  if (Config_getBool(HAVE_DOT) && dp.exists() && dp.isFile())
  {
    pumlArgs += "-graphvizdot \"";
    pumlArgs += dotPath;
    pumlArgs += "\" ";
  }
  switch (format)
  {
    case PlantumlManager::PUML_BITMAP:
      pumlType="png";
      break;
    case PlantumlManager::PUML_EPS:
      pumlType="eps";
      break;
    case PlantumlManager::PUML_SVG:
      pumlType="svg";
      break;
  }
 
  {
    for (const auto &[name,nb] : plantumlContent)
    {
      if (nb.content.empty()) continue;
 
      DString pumlArguments = pumlArgs;
      msg("Generating PlantUML {} Files in {}\n",pumlType,name);
      pumlArguments+="-o \"";
      pumlArguments+=nb.outDir;
      pumlArguments+="\" ";
      pumlArguments+="-charset UTF-8 -t";
      pumlArguments+=pumlType;
      pumlArguments+=" ";
 
      DString puFileName("");
      puFileName+=nb.outDir;
      puFileName+="/";
      pumlOutDir=puFileName;
      puFileName+="inline_umlgraph_";
      puFileName+=pumlType;
      puFileName+=name.c_str();
      puFileName+=".pu";
 
      pumlArguments+="\"";
      pumlArguments+=puFileName;
      pumlArguments+="\" ";
 
 
      DString cachedContent;
      FileInfo fi(puFileName.str());
      if (fi.exists())
      {
        cachedContent = fileToString(puFileName);
      }
 
      std::ofstream file = Portable::openOutputStream(puFileName);
      if (!file.is_open())
      {
        err_full(nb.srcFile,nb.srcLine,"Could not open file {} for writing",puFileName);
      }
      file.write( nb.content.data(), nb.content.length() );
      file.close();
      Debug::print(Debug::Plantuml,0,"*** PlantumlManager::runPlantumlContent Running Plantuml arguments:{}\n",pumlArguments);
 
      if (cachedContent == nb.content) continue;
 
      if ((exitCode=Portable::system(pumlExe.data(),pumlArguments.data(),true))!=0)
      {
        err_full(nb.srcFile,nb.srcLine,"Problems running PlantUML. Verify that the command '{} -h' works from the command line. Exit code: {}.",
            useJar ? pumlExe+" -jar \""+plantumlJarPath+"\"" : pumlExe,exitCode);
      }
 
      if ( (format==PlantumlManager::PUML_EPS) && (Config_getBool(USE_PDFLATEX)) )
      {
        Debug::print(Debug::Plantuml,0,"*** PlantumlManager::runPlantumlContent Running epstopdf\n");
        auto files_kv = plantumlFiles.find(name);
        if (files_kv!=plantumlFiles.end())
        {
          for (const auto &str : files_kv->second)
          {
            const int maxCmdLine = 40960;
            DString epstopdfArgs(maxCmdLine, DString::ExplicitSize);
            epstopdfArgs.sprintf("\"%s%s.eps\" --outfile=\"%s%s.pdf\"",
                pumlOutDir.data(),str.c_str(), pumlOutDir.data(),str.c_str());
            if ((exitCode=Portable::system("epstopdf",epstopdfArgs.data()))!=0)
            {
              err_full(nb.srcFile,nb.srcLine,"Problems running epstopdf. Check your TeX installation! Exit code: {}.",exitCode);
            }
            else
            {
              Dir().remove(pumlOutDir.str()+str+".eps");
            }
          }
        }
      }
    }
  }
}