dirdef.cpp File Reference

#include <algorithm>
#include "dirdef.h"
#include "md5hash.h"
#include "filename.h"
#include "doxygen.h"
#include "util.h"
#include "outputlist.h"
#include "language.h"
#include "message.h"
#include "dot.h"
#include "dotdirdeps.h"
#include "layout.h"
#include "config.h"
#include "docparser.h"
#include "definitionimpl.h"
#include "filedef.h"
#include "trace.h"
#include "portable.h"

Include dependency graph for dirdef.cpp:

Go to the source code of this file.

Classes
class	DirDefImpl

Functions
DirDef *	createDirDef (const DString &path)
static DString	encodeDirName (const DString &anchor)
static void	writePartialDirPath (OutputList &ol, const DirDef *root, const DirDef *target)
static void	writePartialFilePath (OutputList &ol, const DirDef *root, const FileDef *fd)
static void	computeCommonDirPrefix ()
	In order to create stable, but unique directory names, we compute the common part of the path shared by all directories.
void	buildDirectories ()
void	computeDirDependencies ()
void	generateDirDocs (OutputList &ol)
bool	compareDirDefs (const DirDef *item1, const DirDef *item2)
DirDef *	toDirDef (Definition *d)
const DirDef *	toDirDef (const Definition *d)

Function Documentation

buildDirectories()

void buildDirectories

(

)

Definition at line 1095 of file dirdef.cpp.

{
  AUTO_TRACE();
  // for each input file
  for (const auto &fn : *Doxygen::inputNameLinkedMap)
  {
    for (const auto &fd : *fn)
    {
      if (fd->getReference().empty())
      {
        DirDef *dir=Doxygen::dirLinkedMap->find(fd->getPath());
        if (dir==nullptr) // new directory
        {
          dir = DirDefImpl::mergeDirectoryInTree(fd->getPath());
        }
        if (dir && !fd->isDocumentationFile()) dir->addFile(fd.get());
      }
      else
      {
        // do something for file imported via tag files.
      }
    }
  }
 
  // compute relations between directories => introduce container dirs.
  for (const auto &dir : *Doxygen::dirLinkedMap)
  {
    DString name = dir->name();
    size_t i = name.length()>=2 ? name.rfind('/',name.length()-2) : DString::npos;
    if (i!=DString::npos && i>0)
    {
      DirDef *parent = Doxygen::dirLinkedMap->find(name.left(i+1));
      //if (parent==0) parent=root;
      if (parent)
      {
        parent->addSubDir(dir.get());
        AUTO_TRACE_ADD("DirDefImpl::addSubdir(): Adding subdir {} to {}",
                        dir->displayName(), parent->displayName());
      }
    }
  }
 
  // sort the directory contents
  for (const auto &dir : *Doxygen::dirLinkedMap)
  {
    dir->sort();
  }
 
  // short the directories themselves
  std::stable_sort(Doxygen::dirLinkedMap->begin(),
            Doxygen::dirLinkedMap->end(),
            [](const auto &d1,const auto &d2)
            {
              DString s1 = d1->shortName(), s2 = d2->shortName();
              int i = dstricmp_sort(s1,s2);
              if (i==0) // if sort name are equal, sort on full path
              {
                DString n1 = d1->name(), n2 = d2->name();
                int n = dstricmp_sort(n1,n2);
                return n < 0;
              }
              return i < 0;
            });
 
  // set the directory index identifier
  int dirIndex=0;
  for (const auto &dir : *Doxygen::dirLinkedMap)
  {
    dir->setDirIndex(dirIndex++);
  }
 
  computeCommonDirPrefix();
}

References DirDef::addFile(), AUTO_TRACE, AUTO_TRACE_ADD, begin(), computeCommonDirPrefix(), Doxygen::dirLinkedMap, dstricmp_sort(), end(), LinkedMap< T, Hash, KeyEqual, Map >::find(), Doxygen::inputNameLinkedMap, DString::left(), DString::length(), DirDefImpl::mergeDirectoryInTree(), DString::npos, parent(), and DString::rfind().

Referenced by parseInput().

compareDirDefs()

bool compareDirDefs	(	const DirDef *	item1,
		const DirDef *	item2 )

Definition at line 1208 of file dirdef.cpp.

{
  return dstricmp_sort(item1->shortName(),item2->shortName()) < 0;
}

References dstricmp_sort(), and DirDef::shortName().

Referenced by DirDefImpl::sort(), and GroupDefImpl::sortMemberLists().

computeCommonDirPrefix()

void computeCommonDirPrefix ( )

static

In order to create stable, but unique directory names, we compute the common part of the path shared by all directories.

Definition at line 1018 of file dirdef.cpp.

{
  AUTO_TRACE();
  DString path;
  auto it = Doxygen::dirLinkedMap->begin();
  if (!Doxygen::dirLinkedMap->empty()) // we have at least one dir
  {
    // start will full path of first dir
    path=Portable::removeLongPathMarker((*it)->name());
    size_t i = path.length()>=2 ? path.rfind('/',path.length()-2) : DString::npos;
    bool done=false;
    if (i==DString::npos)
    {
      path="";
    }
    else
    {
      path=path.left(i+1);
      while (!done)
      {
        size_t l = path.length();
        size_t count=0;
        for (const auto &dir : *Doxygen::dirLinkedMap)
        {
          DString dirName = Portable::removeLongPathMarker(dir->name());
          //printf("dirName='%s' (l=%d) path='%s' (l=%d)\n",qPrint(dirName),dirName.length(),qPrint(path),path.length());
          if (dirName.length()>path.length())
          {
            if (dirName.left(l)!=path) // dirName does not start with path
            {
              i = l>=2 ? path.rfind('/',l-2) : DString::npos;
              if (i==DString::npos) // no unique prefix -> stop
              {
                path="";
                done=true;
              }
              else // restart with shorter path
              {
                path=path.left(i+1);
                break;
              }
            }
          }
          else // dir is shorter than path -> take path of dir as new start
          {
            path=dir->name();
            l = path.length();
            i = l>=2 ? path.rfind('/',l-2) : DString::npos;
            if (i==DString::npos) // no unique prefix -> stop
            {
              path="";
              done=true;
            }
            else // restart with shorter path
            {
              path=path.left(i+1);
            }
            break;
          }
          count++;
        }
        if (count==Doxygen::dirLinkedMap->size())
          // path matches for all directories -> found the common prefix
        {
          done=true;
        }
      }
    }
  }
  for (const auto &dir : *Doxygen::dirLinkedMap)
  {
    DString diskName = dir->name().right(dir->name().length()-path.length());
    dir->setDiskName(diskName);
    AUTO_TRACE_ADD("set disk name: {} -> {}",dir->name(),diskName);
  }
}

References AUTO_TRACE, AUTO_TRACE_ADD, LinkedMap< T, Hash, KeyEqual, Map >::begin(), Doxygen::dirLinkedMap, DString::left(), DString::length(), DString::npos, Portable::removeLongPathMarker(), DString::rfind(), and DString::right().

Referenced by buildDirectories().

computeDirDependencies()

void computeDirDependencies

(

)

Definition at line 1169 of file dirdef.cpp.

{
  AUTO_TRACE();
  // compute nesting level for each directory
  for (const auto &dir : *Doxygen::dirLinkedMap)
  {
    dir->setLevel();
  }
 
  // compute uses dependencies between directories
  for (const auto &dir : *Doxygen::dirLinkedMap)
  {
    AUTO_TRACE_ADD("computeDependencies for {}: #dirs={}",dir->name(),Doxygen::dirLinkedMap->size());
    dir->computeDependencies();
  }
}

References AUTO_TRACE, AUTO_TRACE_ADD, Doxygen::dirLinkedMap, and LinkedMap< T, Hash, KeyEqual, Map >::size().

Referenced by parseInput().

createDirDef()

DirDef * createDirDef

(

const DString &

path

)

Definition at line 112 of file dirdef.cpp.

{
  return new DirDefImpl(path);
}

Referenced by DirDefImpl::createNewDir().

encodeDirName()

DString encodeDirName ( const DString & anchor )

static

Definition at line 192 of file dirdef.cpp.

{
  AUTO_TRACE();
  // convert to md5 hash
  DString sigStr = md5str(anchor.view());
  AUTO_TRACE_EXIT("result={}",sigStr);
  return sigStr;
}

References AUTO_TRACE, AUTO_TRACE_EXIT, md5str(), and DString::view().

Referenced by DirDefImpl::getOutputFileBase().

generateDirDocs()

void generateDirDocs

(

OutputList &

ol

)

Definition at line 1186 of file dirdef.cpp.

{
  AUTO_TRACE();
  for (const auto &dir : *Doxygen::dirLinkedMap)
  {
    ol.pushGeneratorState();
    if (!dir->hasDocumentation())
    {
      ol.disableAllBut(OutputType::Html);
    }
    dir->writeDocumentation(ol);
    ol.popGeneratorState();
  }
  //if (Config_getBool(DIRECTORY_GRAPH))
  {
    for (const auto &dr : Doxygen::dirRelations)
    {
      dr->writeDocumentation(ol);
    }
  }
}

References AUTO_TRACE, Doxygen::dirLinkedMap, Doxygen::dirRelations, OutputList::disableAllBut(), Html, OutputList::popGeneratorState(), and OutputList::pushGeneratorState().

Referenced by generateOutput().

toDirDef() [1/2]

const DirDef * toDirDef

(

const Definition *

d

)

Definition at line 1228 of file dirdef.cpp.

{
  if (d==nullptr) return nullptr;
  if (d && typeid(*d)==typeid(DirDefImpl))
  {
    return static_cast<const DirDef*>(d);
  }
  else
  {
    return nullptr;
  }
}

toDirDef() [2/2]

DirDef * toDirDef

(

Definition *

d

)

Definition at line 1215 of file dirdef.cpp.

{
  if (d==nullptr) return nullptr;
  if (d && typeid(*d)==typeid(DirDefImpl))
  {
    return static_cast<DirDef*>(d);
  }
  else
  {
    return nullptr;
  }
}

writePartialDirPath()

void writePartialDirPath ( OutputList & ol, const DirDef * root, const DirDef * target )

static

Definition at line 930 of file dirdef.cpp.

{
  if (target->parent()!=root)
  {
    writePartialDirPath(ol,root,target->parent());
    ol.writeString(" / ");
  }
  ol.writeObjectLink(target->getReference(),target->getOutputFileBase(),DString(),target->shortName());
}

References Definition::getOutputFileBase(), Definition::getReference(), DirDef::parent(), DirDef::shortName(), OutputList::writeObjectLink(), writePartialDirPath(), and OutputList::writeString().

Referenced by writePartialDirPath(), and writePartialFilePath().

writePartialFilePath()

void writePartialFilePath ( OutputList & ol, const DirDef * root, const FileDef * fd )

static

Definition at line 940 of file dirdef.cpp.

{
  if (fd->getDirDef() && fd->getDirDef()!=root)
  {
    writePartialDirPath(ol,root,fd->getDirDef());
    ol.writeString(" / ");
  }
  if (fd->isLinkable())
  {
    ol.writeObjectLink(fd->getReference(),fd->getOutputFileBase(),DString(),fd->name());
  }
  else
  {
    ol.startBold();
    ol.docify(fd->name());
    ol.endBold();
  }
}

References OutputList::docify(), OutputList::endBold(), FileDef::getDirDef(), Definition::getOutputFileBase(), Definition::getReference(), Definition::isLinkable(), Definition::name(), OutputList::startBold(), OutputList::writeObjectLink(), writePartialDirPath(), and OutputList::writeString().

Referenced by DirRelation::writeDocumentation().