Config Namespace Reference

Public function to deal with the configuration file. More...

Enumerations
enum class	CompareMode { Full , Compressed , CompressedNoEnv }

Functions
void	init ()
void	writeTemplate (TextStream &t, bool shortList, bool updateOnly=false)
void	compareDoxyfile (TextStream &t, CompareMode compareMode)
void	writeXMLDoxyfile (TextStream &t)
void	writeXSDDoxyfile (TextStream &t)
bool	parse (const DString &fileName, bool update=false, CompareMode compareMode=CompareMode::Full)
void	postProcess (bool clearHeaderAndFooter, CompareMode compareMode=CompareMode::Full)
void	checkAndCorrect (bool quiet, const bool check)
void	updateObsolete ()
void	deinit ()

Detailed Description

Public function to deal with the configuration file.

Enumeration Type Documentation

CompareMode

enum class Config::CompareMode

strong

Enumerator
Full
Compressed
CompressedNoEnv

Definition at line 54 of file config.h.

{ Full, Compressed, CompressedNoEnv };

Function Documentation

checkAndCorrect()

void Config::checkAndCorrect	(	bool	quiet,
		const bool	check )

Check the validity of the parsed options and correct or warn the user where needed.

Parameters

quiet	setting for the QUIET option (can have been overruled by means of a command line option)
check	check HTML / LaTeX header file etc. on existence (and terminate when not present)

Definition at line 1757 of file configimpl.l.

{
  ConfigValues::instance().init();
 
  Config_updateBool(QUIET,quiet || Config_getBool(QUIET));
  //------------------------
  // check WARN_FORMAT
  DString warnFormat = Config_getString(WARN_FORMAT);
  if (warnFormat.find("$file")==DString::npos)
  {
    warn_uncond("warning format does not contain a $file tag!\n");
  }
  if (warnFormat.find("$line")==DString::npos)
  {
    warn_uncond("warning format does not contain a $line tag!\n");
  }
  if (warnFormat.find("$text")==DString::npos)
  {
    warn_uncond("warning format does not contain a $text tag!\n");
  }
 
  //------------------------
  // check and correct PAPER_TYPE
  DString paperType = Config_getEnumAsString(PAPER_TYPE);
  paperType=paperType.lower().stripWhiteSpace();
  if (paperType.empty() || paperType=="a4wide")
  {
    // use a4
    Config_updateEnum(PAPER_TYPE,PAPER_TYPE_t::a4);
  }
  else if (paperType!="a4" && paperType!="letter" &&
           paperType!="legal" && paperType!="executive")
  {
    err("Unknown page type '{}' specified\n",paperType);
    Config_updateEnum(PAPER_TYPE,PAPER_TYPE_t::a4);
  }
 
  //------------------------
  // check & correct STRIP_FROM_PATH
  StringVector stripFromPath = Config_getList(STRIP_FROM_PATH);
  if (stripFromPath.empty()) // by default use the current path
  {
    std::string p = Dir::currentDirPath()+"/";
    stripFromPath.push_back(p);
  }
  else
  {
    cleanUpPaths(stripFromPath);
  }
  Config_updateList(STRIP_FROM_PATH,stripFromPath);
 
  //------------------------
  // check & correct STRIP_FROM_INC_PATH
  StringVector stripFromIncPath = Config_getList(STRIP_FROM_INC_PATH);
  cleanUpPaths(stripFromIncPath);
  Config_updateList(STRIP_FROM_INC_PATH,stripFromIncPath);
 
  //------------------------
  // Test to see if HTML header is valid
  DString headerFile = Config_getString(HTML_HEADER);
  if (check && !headerFile.empty())
  {
    FileInfo fi(headerFile.str());
    if (!fi.exists())
    {
      ConfigImpl::config_term("tag HTML_HEADER: header file '{}' "
          "does not exist\n",headerFile);
    }
  }
 
  //------------------------
  // Test to see if HTML footer is valid
  DString footerFile = Config_getString(HTML_FOOTER);
  if (check && !footerFile.empty())
  {
    FileInfo fi(footerFile.str());
    if (!fi.exists())
    {
      ConfigImpl::config_term("tag HTML_FOOTER: footer file '{}' "
          "does not exist\n",footerFile);
    }
  }
 
  //------------------------
  // Test to see if MathJax code file is valid
  if (Config_getBool(USE_MATHJAX))
  {
    auto mathJaxFormat = Config_getEnum(MATHJAX_FORMAT);
    auto mathjaxVersion = Config_getEnum(MATHJAX_VERSION);
    switch (mathjaxVersion)
    {
      case MATHJAX_VERSION_t::MathJax_2:
        if (mathJaxFormat==MATHJAX_FORMAT_t::chtml)
        {
          Config_updateEnum(MATHJAX_FORMAT,MATHJAX_FORMAT_t::HTML_CSS);
        }
        break;
      case MATHJAX_VERSION_t::MathJax_3:
        if (mathJaxFormat==MATHJAX_FORMAT_t::HTML_CSS || mathJaxFormat==MATHJAX_FORMAT_t::NativeMML)
        {
          Config_updateEnum(MATHJAX_FORMAT,MATHJAX_FORMAT_t::chtml);
        }
        break;
      case MATHJAX_VERSION_t::MathJax_4:
        if (mathJaxFormat==MATHJAX_FORMAT_t::HTML_CSS || mathJaxFormat==MATHJAX_FORMAT_t::NativeMML)
        {
          Config_updateEnum(MATHJAX_FORMAT,MATHJAX_FORMAT_t::chtml);
        }
        break;
    }
 
    DString mathJaxCodefile = Config_getString(MATHJAX_CODEFILE);
    if (check && !mathJaxCodefile.empty())
    {
      FileInfo fi(mathJaxCodefile.str());
      if (!fi.exists())
      {
        ConfigImpl::config_term("tag MATHJAX_CODEFILE file '{}' "
            "does not exist\n",mathJaxCodefile);
      }
    }
    DString path = Config_getString(MATHJAX_RELPATH);
    if (path.empty())
    {
      path = "https://cdn.jsdelivr.net/npm/mathjax@";
      switch (mathjaxVersion)
      {
        case MATHJAX_VERSION_t::MathJax_2: path += "2"; break;
        case MATHJAX_VERSION_t::MathJax_3: path += "3"; break;
        case MATHJAX_VERSION_t::MathJax_4: path += "4"; break;
      }
    }
 
    if (path.at(path.length()-1)!='/')
    {
      path+="/";
    }
    Config_updateString(MATHJAX_RELPATH,path);
  }
 
  //------------------------
  // Test to see if LaTeX header is valid
  DString latexHeaderFile = Config_getString(LATEX_HEADER);
  if (check && !latexHeaderFile.empty())
  {
    FileInfo fi(latexHeaderFile.str());
    if (!fi.exists())
    {
      ConfigImpl::config_term("tag LATEX_HEADER: header file '{}' "
          "does not exist\n",latexHeaderFile);
    }
  }
 
  //------------------------
  // Test to see if LaTeX footer is valid
  DString latexFooterFile = Config_getString(LATEX_FOOTER);
  if (check && !latexFooterFile.empty())
  {
    FileInfo fi(latexFooterFile.str());
    if (!fi.exists())
    {
      ConfigImpl::config_term("tag LATEX_FOOTER: footer file '{}' "
          "does not exist\n",latexFooterFile);
    }
  }
 
  //------------------------
  // check include path
  StringVector includePath = Config_getList(INCLUDE_PATH);
  for (const auto &s : includePath)
  {
    FileInfo fi(s);
    if (!fi.exists())
    {
      warn_uncond("tag INCLUDE_PATH: include path '{}' does not exist\n",s);
    }
  }
 
  //------------------------
  // check PREDEFINED
  if (Config_getBool(ENABLE_PREPROCESSING))
  {
    StringVector predefList = Config_getList(PREDEFINED);
    for (const auto &s : predefList)
    {
      DString predef = s;
      predef=predef.stripWhiteSpace();
      size_t i_equals=predef.find('=');
      size_t i_obrace=predef.find('(');
      if ((i_obrace==0) || (i_equals==0) || (i_equals==1 && predef.at(i_equals-1)==':'))
      {
        err("Illegal PREDEFINED format '{}', no define name specified\n",predef);
      }
    }
  }
 
  //------------------------
  // check EXTENSION_MAPPING
  checkList(Config_getList(EXTENSION_MAPPING),"EXTENSION_MAPPING",true,true);
 
  //------------------------
  // check FILTER_PATTERNS
  checkList(Config_getList(FILTER_PATTERNS),"FILTER_PATTERNS",true,true);
 
  //------------------------
  // check FILTER_SOURCE_PATTERNS
  checkList(Config_getList(FILTER_SOURCE_PATTERNS),"FILTER_SOURCE_PATTERNS",false,false);
 
  //------------------------
  // check INPUT_FILE_ENCODING
  checkList(Config_getList(INPUT_FILE_ENCODING),"INPUT_FILE_ENCODING",true,true);
 
  //------------------------
  // check TAGFILES
  checkList(Config_getList(TAGFILES),"TAGFILES",false,true);
 
  //------------------------
  // check EXTRA_SEARCH_MAPPINGS
  if (Config_getBool(SEARCHENGINE) && Config_getBool(GENERATE_HTML))
  {
    checkList(Config_getList(EXTRA_SEARCH_MAPPINGS),"EXTRA_SEARCH_MAPPING",true,true);
  }
 
  int numThreads = Config_getInt(NUM_PROC_THREADS);
  if (numThreads==0)
  {
     numThreads = static_cast<int>(std::thread::hardware_concurrency());
     Config_updateInt(NUM_PROC_THREADS,numThreads);
  }
 
  //------------------------
 
  // check for settings that are inconsistent with having GENERATE_HTMLHELP enabled
  if (Config_getBool(GENERATE_HTMLHELP))
  {
    const char *depOption = "GENERATE_HTMLHELP";
    adjustBoolSetting(  depOption, "GENERATE_TREEVIEW",    false  );
    adjustBoolSetting(  depOption, "SEARCHENGINE",         false  );
    adjustBoolSetting(  depOption, "HTML_DYNAMIC_MENUS",   false  );
    adjustBoolSetting(  depOption, "HTML_DYNAMIC_SECTIONS",false  );
    adjustBoolSetting(  depOption, "HTML_COPY_CLIPBOARD",  false  );
    adjustBoolSetting(  depOption, "HTML_CODE_FOLDING",    false  );
    adjustBoolSetting(  depOption, "INTERACTIVE_SVG",      false  );
    adjustStringSetting(depOption, "HTML_FILE_EXTENSION", ".html");
    adjustStringSetting(depOption, "MERMAID_RENDER_MODE", "CLI");
    adjustColorStyleSetting(depOption);
    StringVector tagFileList = Config_getList(TAGFILES);
    StringVector filteredTagFileList;
    for (const auto &s : tagFileList)
    {
      bool validUrl = false;
      size_t eqPos = s.find('=');
      if (eqPos!=std::string::npos) // tag command contains a destination
      {
        DString url = DString(s.substr(eqPos+1)).stripWhiteSpace().lower();
        validUrl = url.startsWith("http:") || url.startsWith("https:") ||
                   url.startsWith("ms-its:");
      }
      if (validUrl)
      {
        filteredTagFileList.push_back(s);
      }
      else
      {
        err("When enabling GENERATE_HTMLHELP the TAGFILES option should only contain destinations "
            "with https / http addresses (not: {}). I'll adjust it for you.\n",s);
      }
    }
    Config_updateList(TAGFILES,filteredTagFileList);
  }
 
  // check for settings that are inconsistent with having INLINE_GROUPED_CLASSES enabled
  if (Config_getBool(INLINE_GROUPED_CLASSES))
  {
    const char *depOption = "INLINE_GROUPED_CLASSES";
    adjustBoolSetting(depOption, "SEPARATE_MEMBER_PAGES", false);
  }
 
  //------------------------
  int dotNumThreads = Config_getInt(DOT_NUM_THREADS);
  if (dotNumThreads<=0)
  {
    dotNumThreads=std::max(2u,std::thread::hardware_concurrency()+1);
    Config_updateInt(DOT_NUM_THREADS,dotNumThreads);
  }
 
  //------------------------
  // check plantuml path
  DString plantumlJarPath = Config_getString(PLANTUML_JAR_PATH);
  if (!plantumlJarPath.empty())
  {
    FileInfo pu(plantumlJarPath.str());
    if (pu.exists() && pu.isDir()) // PLANTUML_JAR_PATH is directory
    {
      DString plantumlJar = plantumlJarPath+Portable::pathSeparator()+"plantuml.jar";
      FileInfo jar(plantumlJar.str());
      if (jar.exists() && jar.isFile())
      {
        plantumlJarPath = plantumlJar;
      }
      else
      {
        err("Jar file 'plantuml.jar' not found at location specified via PLANTUML_JAR_PATH: '{}'\n",plantumlJarPath);
        plantumlJarPath="";
      }
    }
    else if (pu.exists() && pu.isFile()) // PLANTUML_JAR_PATH is file
    {
      // Nothing to be done
    }
    else
    {
      err("PLANTUML_JAR_PATH is not a directory with a 'plantuml.jar' file or is not an existing file: {}\n",plantumlJarPath);
      plantumlJarPath="";
    }
    Config_updateString(PLANTUML_JAR_PATH,plantumlJarPath);
  }
 
  //------------------------
  // check dia path
  DString diaPath = Config_getString(DIA_PATH);
  if (!diaPath.empty())
  {
    DString diaExe = diaPath+"/dia"+Portable::commandExtension();
    FileInfo dp(diaExe.str());
    if (!dp.exists() || !dp.isFile())
    {
      warn_uncond("dia could not be found at {}\n",diaPath);
      diaPath="";
    }
    else
    {
      diaPath=dp.dirPath(true)+"/";
#if defined(_WIN32) // convert slashes
      size_t i=0,l=diaPath.length();
      for (i=0;i<l;i++) if (diaPath.at(i)=='/') diaPath.at(i)='\\';
#endif
    }
    Config_updateString(DIA_PATH,diaPath);
  }
 
  //------------------------
  // check INPUT
  StringVector inputSources=Config_getList(INPUT);
  if (inputSources.empty())
  {
    // use current dir as the default
    inputSources.push_back(Dir::currentDirPath());
  }
  else
  {
    for (const auto &s : inputSources)
    {
      FileInfo fi(s);
      if (!fi.exists())
      {
        warn_uncond("tag INPUT: input source '{}' does not exist\n",s);
      }
    }
  }
  Config_updateList(INPUT,inputSources);
 
  //------------------------
  // if no output format is enabled, warn the user
  if (!Config_getBool(GENERATE_HTML)    &&
      !Config_getBool(GENERATE_LATEX)   &&
      !Config_getBool(GENERATE_MAN)     &&
      !Config_getBool(GENERATE_RTF)     &&
      !Config_getBool(GENERATE_XML)     &&
      !Config_getBool(GENERATE_PERLMOD) &&
      !Config_getBool(GENERATE_RTF)     &&
      !Config_getBool(GENERATE_DOCBOOK) &&
      !Config_getBool(GENERATE_AUTOGEN_DEF) &&
      Config_getString(GENERATE_TAGFILE).empty()
     )
  {
    warn_uncond("No output formats selected! Set at least one of the main GENERATE_* options to YES.\n");
  }
 
  //------------------------
  // check HTMLHELP creation requirements
  if (!Config_getBool(GENERATE_HTML) &&
      Config_getBool(GENERATE_HTMLHELP))
  {
    warn_uncond("GENERATE_HTMLHELP=YES requires GENERATE_HTML=YES.\n");
  }
 
  //------------------------
  // check sitemap creation requirements
  if (!Config_getBool(GENERATE_HTML) &&
      !Config_getString(SITEMAP_URL).empty())
  {
    warn_uncond("Setting SITEMAP_URL requires GENERATE_HTML=YES.\n");
  }
 
  //------------------------
  // check QHP creation requirements
  if (Config_getBool(GENERATE_QHP))
  {
    if (!Config_getBool(GENERATE_HTML))
    {
      warn_uncond("GENERATE_QHP=YES requires GENERATE_HTML=YES.\n");
    }
    if (Config_getString(QHP_NAMESPACE).empty())
    {
      err("GENERATE_QHP=YES requires QHP_NAMESPACE to be set. Using 'org.doxygen.doc' as default!.\n");
      Config_updateString(QHP_NAMESPACE,"org.doxygen.doc");
    }
 
    if (Config_getString(QHP_VIRTUAL_FOLDER).empty())
    {
      err("GENERATE_QHP=YES requires QHP_VIRTUAL_FOLDER to be set. Using 'doc' as default!\n");
      Config_updateString(QHP_VIRTUAL_FOLDER,"doc");
    }
    StringVector tagFileList = Config_getList(TAGFILES);
    if (!tagFileList.empty())
    {
      err("When enabling GENERATE_QHP the TAGFILES option should be empty. I'll adjust it for you.\n");
      Config_updateList(TAGFILES,StringVector());
    }
  }
 
  //------------------------
  if (Config_getBool(OPTIMIZE_OUTPUT_JAVA) && Config_getBool(INLINE_INFO))
  {
    // don't show inline info for Java output, since Java has no inline
    // concept.
    Config_updateBool(INLINE_INFO,false);
  }
 
  //------------------------
  int depth = Config_getInt(MAX_DOT_GRAPH_DEPTH);
  if (depth==0)
  {
    Config_updateInt(MAX_DOT_GRAPH_DEPTH,1000);
  }
 
  //------------------------
  if (Config_getBool(INTERACTIVE_SVG))
  {
    // issue 11308
    if ((Config_getEnum(DOT_IMAGE_FORMAT) == DOT_IMAGE_FORMAT_t::svg_cairo) ||
        (Config_getEnum(DOT_IMAGE_FORMAT) == DOT_IMAGE_FORMAT_t::svg_cairo_cairo))
    {
      err("When using DOT_IMAGE_FORMAT with {} the INTERACTIVE_SVG option should be disabled. I'll adjust it for you.\n",
          Config_getEnumAsString(DOT_IMAGE_FORMAT));
      Config_updateBool(INTERACTIVE_SVG,false);
    }
  }
 
  //------------------------
  // check for settings that are inconsistent with having OPTIMIZED_OUTPUT_VHDL enabled
  if (Config_getBool(OPTIMIZE_OUTPUT_VHDL))
  {
    const char *depOption = "OPTIMIZE_OUTPUT_VHDL";
    adjustBoolSetting(depOption,"INLINE_INHERITED_MEMB",false);
    adjustBoolSetting(depOption,"INHERIT_DOCS",         false);
    adjustBoolSetting(depOption,"HIDE_SCOPE_NAMES",     true );
    adjustBoolSetting(depOption,"EXTRACT_PRIVATE",      true );
    adjustBoolSetting(depOption,"ENABLE_PREPROCESSING", false);
    adjustBoolSetting(depOption,"EXTRACT_PACKAGE",      true );
  }
 
  if (!checkFileName(Config_getString(GENERATE_TAGFILE),"GENERATE_TAGFILE"))
  {
    Config_updateString(GENERATE_TAGFILE,"");
  }
 
#if 0 // TODO: this breaks test 25; SOURCEBROWSER = NO and SOURCE_TOOLTIPS = YES.
      // So this and other regressions should be analyzed and fixed before this can be enabled
  // disable any boolean options that depend on disabled options
  for (const auto &option : m_options)
  {
    DString depName = option->dependsOn(); // option has a dependency
    if (!depName.empty())
    {
      ConfigOption * dep = Config::instance()->get(depName);
      if (dep->kind()==ConfigOption::O_Bool &&
          ConfigImpl_getBool("depName")==false) // dependent option is disabled
      {
        if (option->kind()==ConfigOption::O_Bool)
        {
          printf("disabling option %s\n",qPrint(option->name()));
          ConfigImpl_getBool("option->name("))=false; // also disable this option
        }
      }
    }
  }
#endif
 
}

References adjustBoolSetting(), adjustColorStyleSetting(), adjustStringSetting(), DString::at(), checkFileName(), checkList(), cleanUpPaths(), Portable::commandExtension(), Config_getBool, Config_getEnum, Config_getEnumAsString, Config_getInt, Config_getList, Config_getString, ConfigImpl::config_term(), Config_updateBool, Config_updateEnum, Config_updateInt, Config_updateList, Config_updateString, ConfigImpl_getBool, Dir::currentDirPath(), ConfigOption::dependsOn(), FileInfo::dirPath(), DString::empty(), err, FileInfo::exists(), DString::find(), FileInfo::isDir(), FileInfo::isFile(), ConfigOption::kind(), DString::length(), DString::lower(), ConfigOption::name(), DString::npos, ConfigOption::O_Bool, Portable::pathSeparator(), DString::push_back(), qPrint(), DString::startsWith(), DString::str(), stripFromPath(), DString::stripWhiteSpace(), and warn_uncond.

Referenced by checkConfiguration(), and readConfiguration().

compareDoxyfile()

void Config::compareDoxyfile	(	TextStream &	t,
		Config::CompareMode	compareMode )

Writes a the differences between the current configuration and the template configuration to stream t.

Definition at line 2359 of file configimpl.l.

{
  postProcess(false, compareMode);
  ConfigImpl::instance()->compareDoxyfile(t, compareMode);
}

References ConfigImpl::compareDoxyfile(), ConfigImpl::instance(), and postProcess().

Referenced by compareDoxyfile().

deinit()

void Config::deinit

(

)

Clean up any data

Definition at line 2407 of file configimpl.l.

{
  ConfigImpl::instance()->deleteInstance();
}

References ConfigImpl::deleteInstance(), and ConfigImpl::instance().

Referenced by generateOutput().

init()

void Config::init

(

)

Initialize configuration variables to their default value

Definition at line 1666 of file configimpl.l.

{
  ConfigImpl::instance()->init();
}

References ConfigImpl::init(), and ConfigImpl::instance().

Referenced by readConfiguration().

parse()

bool Config::parse	(	const DString &	fileName,
		bool	update = false,
		Config::CompareMode	compareMode = CompareMode::Full )

Parses a configuration file with name fn.

Returns

true if successful, false if the file could not be opened or read.

Definition at line 2375 of file configimpl.l.

{
  g_compareMode = compareMode;
  bool parseRes = ConfigImpl::instance()->parse(fileName,update);
  if (!parseRes) return parseRes;
 
  // Internally we use the default format UTF-8 and
  // when updating etc. the output is in this format as well and not in the read format
  ConfigString *option = dynamic_cast<ConfigString*>(g_config->get("DOXYFILE_ENCODING"));
  if (option) option->init();
 
  return parseRes;
}

References g_compareMode, g_config, ConfigImpl::get(), ConfigString::init(), ConfigImpl::instance(), and ConfigImpl::parse().

Referenced by readConfiguration().

postProcess()

void Config::postProcess	(	bool	clearHeaderAndFooter,
		Config::CompareMode	compareMode = CompareMode::Full )

Post processed the parsed data. Replaces raw string values by the actual values. and replaces environment variables.

Parameters

clearHeaderAndFooter	set to true when writing header and footer templates.
compareMode	signals if we in Doxyfile compare (-x or -x_noenv) mode are or not. Influences setting of the default value and replacement of environment variables and CMake type replacement variables.

Definition at line 2389 of file configimpl.l.

{
  auto configInst = ConfigImpl::instance();
  if (compareMode != CompareMode::CompressedNoEnv) configInst->substituteEnvironmentVars();
  if (compareMode == CompareMode::Full)            configInst->emptyValueToDefault();
  configInst->convertStrToVal(compareMode);
 
  // avoid bootstrapping issues when the g_config file already
  // refers to the files that we are supposed to parse.
  if (clearHeaderAndFooter)
  {
    Config_updateString(HTML_HEADER ,"");
    Config_updateString(HTML_FOOTER ,"");
    Config_updateString(LATEX_HEADER,"");
    Config_updateString(LATEX_FOOTER,"");
  }
}

References CompressedNoEnv, Config_updateString, Full, and ConfigImpl::instance().

Referenced by checkConfiguration(), compareDoxyfile(), and readConfiguration().

updateObsolete()

void Config::updateObsolete

(

)

Adjust any configuration values based on the value of obsolete options.

Definition at line 2254 of file configimpl.l.

{
  //------------------------
  // check for presence of obsolete CLASS_DIAGRAM option and correct CLASS_GRAPH if needed
  ConfigOption *classDiagramsOpt = ConfigImpl::instance()->get("CLASS_DIAGRAMS");
  ConfigOption *haveDotOpt       = ConfigImpl::instance()->get("HAVE_DOT");
  ConfigOption *classGraphOpt    = ConfigImpl::instance()->get("CLASS_GRAPH");
  if (classDiagramsOpt && classDiagramsOpt->kind()==ConfigOption::O_Obsolete &&
      haveDotOpt && classGraphOpt)
  {
    ConfigObsolete *classDiagramsOpt_ = dynamic_cast<ConfigObsolete*>(classDiagramsOpt);
    ConfigBool     *haveDotOpt_       = dynamic_cast<ConfigBool*>(haveDotOpt);
    ConfigEnum     *classGraphOpt_    = dynamic_cast<ConfigEnum*>(classGraphOpt);
    if (classDiagramsOpt_ && haveDotOpt_ && classGraphOpt_ &&
        classDiagramsOpt_->isPresent() && classDiagramsOpt_->orgType()==ConfigOption::O_Bool)
    {
      DString classDiagramValue = *classDiagramsOpt_->valueStringRef();
      DString haveDotValue      = *haveDotOpt_->valueStringRef();
      DString &classGraphValue  = *classGraphOpt_->valueRef();
      bool isValid1=true, isValid2=true;
      bool bClassDiagrams = convertStringToBool(classDiagramValue,isValid1);
      bool bHaveDot       = haveDotValue.empty() ? false : convertStringToBool(haveDotValue,     isValid2);
      if (isValid1 && isValid2 && !bClassDiagrams && !bHaveDot && classGraphValue.lower()=="yes")
      {
        warn_uncond("Changing CLASS_GRAPH option to TEXT because obsolete option CLASS_DIAGRAM was found and set to NO.\n");
        classGraphValue="TEXT";
      }
    }
  }
 
  // update TIMESTAMP based on HTML_TIMESTAMP and LATEX_TIMESTAMP
  ConfigOption *HtmlTimestamp = ConfigImpl::instance()->get("HTML_TIMESTAMP");
  ConfigOption *timestampOpt    = ConfigImpl::instance()->get("TIMESTAMP");
  bool reset = false;
  if (HtmlTimestamp && HtmlTimestamp->kind()==ConfigOption::O_Obsolete && timestampOpt)
  {
    ConfigObsolete *htmlTimestamp_ = dynamic_cast<ConfigObsolete*>(HtmlTimestamp);
    ConfigEnum     *timestampOpt_ = dynamic_cast<ConfigEnum*>(timestampOpt);
    if (htmlTimestamp_ && timestampOpt_ &&
        htmlTimestamp_->isPresent() && htmlTimestamp_->orgType()==ConfigOption::O_Bool)
    {
      DString &timestampValue  = *timestampOpt_->valueRef();
      DString htmlTimestampValue = *htmlTimestamp_->valueStringRef();
      bool isValid=true;
      bool bTimestamp = convertStringToBool(htmlTimestampValue,isValid);
      if (isValid && bTimestamp)
      {
        reset = true;
        timestampValue = "YES";
      }
    }
  }
  ConfigOption *LatexTimestamp = ConfigImpl::instance()->get("LATEX_TIMESTAMP");
  if (!reset && LatexTimestamp && LatexTimestamp->kind()==ConfigOption::O_Obsolete && timestampOpt)
  {
    ConfigObsolete *latexTimestamp_ = dynamic_cast<ConfigObsolete*>(LatexTimestamp);
    ConfigEnum     *timestampOpt_ = dynamic_cast<ConfigEnum*>(timestampOpt);
    if (latexTimestamp_ && timestampOpt_ &&
        latexTimestamp_->isPresent() && latexTimestamp_->orgType()==ConfigOption::O_Bool)
    {
      DString &timestampValue  = *timestampOpt_->valueRef();
      DString latexTimestampValue = *latexTimestamp_->valueStringRef();
      bool isValid=true;
      bool bTimestamp = convertStringToBool(latexTimestampValue,isValid);
      if (isValid && bTimestamp) timestampValue = "YES";
    }
  }
 
  auto fontname = dynamic_cast<ConfigObsolete*>(ConfigImpl::instance()->get("DOT_FONTNAME"));
  auto fontsize = dynamic_cast<ConfigObsolete*>(ConfigImpl::instance()->get("DOT_FONTSIZE"));
 
  // correct DOT_FONTNAME if needed
  if (fontname &&
      (*fontname->valueStringRef() == "FreeSans"
      || *fontname->valueStringRef() == "FreeSans.ttf"))
    warn_uncond("doxygen no longer ships with the FreeSans font.\n"
               "  You may want to clear or change DOT_FONTNAME.\n"
               "  Otherwise you run the risk that the wrong font is being used for dot generated graphs.\n");
 
  auto commonAttrOpt = dynamic_cast<ConfigString*>(ConfigImpl::instance()->get("DOT_COMMON_ATTR"));
  if (commonAttrOpt)
  {
    DString& commonAttrStr = *commonAttrOpt->valueRef();
    DotAttributes commonAttr(commonAttrStr);
    updateAttribute(commonAttr, "fontname", fontname);
    updateAttribute(commonAttr, "fontsize", fontsize);
    commonAttrStr = commonAttr.str();
  }
 
  auto edgeAttrOpt = dynamic_cast<ConfigString*>(ConfigImpl::instance()->get("DOT_EDGE_ATTR"));
  if (edgeAttrOpt)
  {
    DString& edgeAttrStr = *edgeAttrOpt->valueRef();
    DotAttributes edgeAttr(edgeAttrStr);
    updateAttribute(edgeAttr, "labelfontname", fontname);
    updateAttribute(edgeAttr, "labelfontsize", fontsize);
    edgeAttrStr = edgeAttr.str();
  }
}

References convertStringToBool(), DString::empty(), ConfigImpl::get(), ConfigImpl::instance(), ConfigObsolete::isPresent(), ConfigOption::kind(), DString::lower(), ConfigOption::O_Bool, ConfigOption::O_Obsolete, ConfigObsolete::orgType(), DotAttributes::str(), updateAttribute(), ConfigEnum::valueRef(), ConfigBool::valueStringRef(), ConfigObsolete::valueStringRef(), and warn_uncond.

Referenced by checkConfiguration(), and readConfiguration().

writeTemplate()

void Config::writeTemplate	(	TextStream &	t,
		bool	shortList,
		bool	updateOnly = false )

Writes a template configuration to stream t. If shortList is true the description of each configuration option will be omitted.

Definition at line 2354 of file configimpl.l.

{
  ConfigImpl::instance()->writeTemplate(t,shortList,update);
}

References ConfigImpl::instance(), and ConfigImpl::writeTemplate().

Referenced by generateConfigFile().

writeXMLDoxyfile()

void Config::writeXMLDoxyfile

(

TextStream &

t

)

Writes a the used settings of the current configuration as XML format to stream t.

Definition at line 2365 of file configimpl.l.

{
  ConfigImpl::instance()->writeXMLDoxyfile(t);
}

References ConfigImpl::instance(), and ConfigImpl::writeXMLDoxyfile().

Referenced by generateXML().

writeXSDDoxyfile()

void Config::writeXSDDoxyfile

(

TextStream &

t

)

Writes all possible setting ids to an XSD file for validation through the stream t.

Definition at line 2370 of file configimpl.l.

{
  ConfigImpl::instance()->writeXSDDoxyfile(t);
}

References ConfigImpl::instance(), and ConfigImpl::writeXSDDoxyfile().

Referenced by generateXML().